netbox_openapi/apis/
virtualization_api.rs

1/*
2 * NetBox REST API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 4.5.9-Docker-4.0.2 (4.5)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`virtualization_cluster_groups_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum VirtualizationClusterGroupsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`virtualization_cluster_groups_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum VirtualizationClusterGroupsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`virtualization_cluster_groups_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum VirtualizationClusterGroupsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`virtualization_cluster_groups_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum VirtualizationClusterGroupsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`virtualization_cluster_groups_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum VirtualizationClusterGroupsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`virtualization_cluster_groups_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum VirtualizationClusterGroupsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`virtualization_cluster_groups_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum VirtualizationClusterGroupsPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`virtualization_cluster_groups_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum VirtualizationClusterGroupsRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`virtualization_cluster_groups_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum VirtualizationClusterGroupsUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`virtualization_cluster_types_bulk_destroy`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum VirtualizationClusterTypesBulkDestroyError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`virtualization_cluster_types_bulk_partial_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum VirtualizationClusterTypesBulkPartialUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`virtualization_cluster_types_bulk_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum VirtualizationClusterTypesBulkUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`virtualization_cluster_types_create`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum VirtualizationClusterTypesCreateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`virtualization_cluster_types_destroy`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum VirtualizationClusterTypesDestroyError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`virtualization_cluster_types_list`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum VirtualizationClusterTypesListError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`virtualization_cluster_types_partial_update`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum VirtualizationClusterTypesPartialUpdateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`virtualization_cluster_types_retrieve`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum VirtualizationClusterTypesRetrieveError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`virtualization_cluster_types_update`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum VirtualizationClusterTypesUpdateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`virtualization_clusters_bulk_destroy`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum VirtualizationClustersBulkDestroyError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`virtualization_clusters_bulk_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum VirtualizationClustersBulkPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`virtualization_clusters_bulk_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum VirtualizationClustersBulkUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`virtualization_clusters_create`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum VirtualizationClustersCreateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`virtualization_clusters_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum VirtualizationClustersDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`virtualization_clusters_list`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum VirtualizationClustersListError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`virtualization_clusters_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum VirtualizationClustersPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`virtualization_clusters_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum VirtualizationClustersRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`virtualization_clusters_update`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum VirtualizationClustersUpdateError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`virtualization_interfaces_bulk_destroy`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum VirtualizationInterfacesBulkDestroyError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`virtualization_interfaces_bulk_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum VirtualizationInterfacesBulkPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`virtualization_interfaces_bulk_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum VirtualizationInterfacesBulkUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`virtualization_interfaces_create`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum VirtualizationInterfacesCreateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`virtualization_interfaces_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum VirtualizationInterfacesDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`virtualization_interfaces_list`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum VirtualizationInterfacesListError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`virtualization_interfaces_partial_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum VirtualizationInterfacesPartialUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`virtualization_interfaces_retrieve`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum VirtualizationInterfacesRetrieveError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`virtualization_interfaces_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum VirtualizationInterfacesUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`virtualization_virtual_disks_bulk_destroy`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum VirtualizationVirtualDisksBulkDestroyError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`virtualization_virtual_disks_bulk_partial_update`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum VirtualizationVirtualDisksBulkPartialUpdateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`virtualization_virtual_disks_bulk_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum VirtualizationVirtualDisksBulkUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`virtualization_virtual_disks_create`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum VirtualizationVirtualDisksCreateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`virtualization_virtual_disks_destroy`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum VirtualizationVirtualDisksDestroyError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`virtualization_virtual_disks_list`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum VirtualizationVirtualDisksListError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`virtualization_virtual_disks_partial_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum VirtualizationVirtualDisksPartialUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`virtualization_virtual_disks_retrieve`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum VirtualizationVirtualDisksRetrieveError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`virtualization_virtual_disks_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum VirtualizationVirtualDisksUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`virtualization_virtual_machines_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VirtualizationVirtualMachinesBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`virtualization_virtual_machines_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VirtualizationVirtualMachinesBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`virtualization_virtual_machines_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VirtualizationVirtualMachinesBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`virtualization_virtual_machines_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VirtualizationVirtualMachinesCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`virtualization_virtual_machines_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VirtualizationVirtualMachinesDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`virtualization_virtual_machines_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VirtualizationVirtualMachinesListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`virtualization_virtual_machines_partial_update`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VirtualizationVirtualMachinesPartialUpdateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`virtualization_virtual_machines_render_config_create`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VirtualizationVirtualMachinesRenderConfigCreateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`virtualization_virtual_machines_retrieve`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum VirtualizationVirtualMachinesRetrieveError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`virtualization_virtual_machines_update`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum VirtualizationVirtualMachinesUpdateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// Delete a list of cluster group objects.
402pub async fn virtualization_cluster_groups_bulk_destroy(
403    configuration: &configuration::Configuration,
404    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
405) -> Result<(), Error<VirtualizationClusterGroupsBulkDestroyError>> {
406    let local_var_configuration = configuration;
407
408    let local_var_client = &local_var_configuration.client;
409
410    let local_var_uri_str = format!(
411        "{}/api/virtualization/cluster-groups/",
412        local_var_configuration.base_path
413    );
414    let mut local_var_req_builder =
415        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
416
417    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
418        local_var_req_builder =
419            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
420    }
421    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
422        let local_var_key = local_var_apikey.key.clone();
423        let local_var_value = match local_var_apikey.prefix {
424            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
425            None => local_var_key,
426        };
427        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
428    };
429    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
430
431    let local_var_req = local_var_req_builder.build()?;
432    let local_var_resp = local_var_client.execute(local_var_req).await?;
433
434    let local_var_status = local_var_resp.status();
435    let local_var_content = local_var_resp.text().await?;
436
437    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
438        Ok(())
439    } else {
440        let local_var_entity: Option<VirtualizationClusterGroupsBulkDestroyError> =
441            serde_json::from_str(&local_var_content).ok();
442        let local_var_error = ResponseContent {
443            status: local_var_status,
444            content: local_var_content,
445            entity: local_var_entity,
446        };
447        Err(Error::ResponseError(local_var_error))
448    }
449}
450
451/// Patch a list of cluster group objects.
452pub async fn virtualization_cluster_groups_bulk_partial_update(
453    configuration: &configuration::Configuration,
454    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
455) -> Result<
456    Vec<crate::models::ClusterGroup>,
457    Error<VirtualizationClusterGroupsBulkPartialUpdateError>,
458> {
459    let local_var_configuration = configuration;
460
461    let local_var_client = &local_var_configuration.client;
462
463    let local_var_uri_str = format!(
464        "{}/api/virtualization/cluster-groups/",
465        local_var_configuration.base_path
466    );
467    let mut local_var_req_builder =
468        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
469
470    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
471        local_var_req_builder =
472            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
473    }
474    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
475        let local_var_key = local_var_apikey.key.clone();
476        let local_var_value = match local_var_apikey.prefix {
477            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
478            None => local_var_key,
479        };
480        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
481    };
482    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
483
484    let local_var_req = local_var_req_builder.build()?;
485    let local_var_resp = local_var_client.execute(local_var_req).await?;
486
487    let local_var_status = local_var_resp.status();
488    let local_var_content = local_var_resp.text().await?;
489
490    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
491        serde_json::from_str(&local_var_content).map_err(Error::from)
492    } else {
493        let local_var_entity: Option<VirtualizationClusterGroupsBulkPartialUpdateError> =
494            serde_json::from_str(&local_var_content).ok();
495        let local_var_error = ResponseContent {
496            status: local_var_status,
497            content: local_var_content,
498            entity: local_var_entity,
499        };
500        Err(Error::ResponseError(local_var_error))
501    }
502}
503
504/// Put a list of cluster group objects.
505pub async fn virtualization_cluster_groups_bulk_update(
506    configuration: &configuration::Configuration,
507    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
508) -> Result<Vec<crate::models::ClusterGroup>, Error<VirtualizationClusterGroupsBulkUpdateError>> {
509    let local_var_configuration = configuration;
510
511    let local_var_client = &local_var_configuration.client;
512
513    let local_var_uri_str = format!(
514        "{}/api/virtualization/cluster-groups/",
515        local_var_configuration.base_path
516    );
517    let mut local_var_req_builder =
518        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
519
520    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
521        local_var_req_builder =
522            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
523    }
524    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
525        let local_var_key = local_var_apikey.key.clone();
526        let local_var_value = match local_var_apikey.prefix {
527            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
528            None => local_var_key,
529        };
530        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
531    };
532    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
533
534    let local_var_req = local_var_req_builder.build()?;
535    let local_var_resp = local_var_client.execute(local_var_req).await?;
536
537    let local_var_status = local_var_resp.status();
538    let local_var_content = local_var_resp.text().await?;
539
540    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
541        serde_json::from_str(&local_var_content).map_err(Error::from)
542    } else {
543        let local_var_entity: Option<VirtualizationClusterGroupsBulkUpdateError> =
544            serde_json::from_str(&local_var_content).ok();
545        let local_var_error = ResponseContent {
546            status: local_var_status,
547            content: local_var_content,
548            entity: local_var_entity,
549        };
550        Err(Error::ResponseError(local_var_error))
551    }
552}
553
554/// Post a list of cluster group objects.
555pub async fn virtualization_cluster_groups_create(
556    configuration: &configuration::Configuration,
557    virtualization_cluster_groups_create_request: crate::models::VirtualizationClusterGroupsCreateRequest,
558) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsCreateError>> {
559    let local_var_configuration = configuration;
560
561    let local_var_client = &local_var_configuration.client;
562
563    let local_var_uri_str = format!(
564        "{}/api/virtualization/cluster-groups/",
565        local_var_configuration.base_path
566    );
567    let mut local_var_req_builder =
568        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
569
570    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
571        local_var_req_builder =
572            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
573    }
574    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
575        let local_var_key = local_var_apikey.key.clone();
576        let local_var_value = match local_var_apikey.prefix {
577            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
578            None => local_var_key,
579        };
580        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
581    };
582    local_var_req_builder =
583        local_var_req_builder.json(&virtualization_cluster_groups_create_request);
584
585    let local_var_req = local_var_req_builder.build()?;
586    let local_var_resp = local_var_client.execute(local_var_req).await?;
587
588    let local_var_status = local_var_resp.status();
589    let local_var_content = local_var_resp.text().await?;
590
591    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
592        serde_json::from_str(&local_var_content).map_err(Error::from)
593    } else {
594        let local_var_entity: Option<VirtualizationClusterGroupsCreateError> =
595            serde_json::from_str(&local_var_content).ok();
596        let local_var_error = ResponseContent {
597            status: local_var_status,
598            content: local_var_content,
599            entity: local_var_entity,
600        };
601        Err(Error::ResponseError(local_var_error))
602    }
603}
604
605/// Delete a cluster group object.
606pub async fn virtualization_cluster_groups_destroy(
607    configuration: &configuration::Configuration,
608    id: i32,
609) -> Result<(), Error<VirtualizationClusterGroupsDestroyError>> {
610    let local_var_configuration = configuration;
611
612    let local_var_client = &local_var_configuration.client;
613
614    let local_var_uri_str = format!(
615        "{}/api/virtualization/cluster-groups/{id}/",
616        local_var_configuration.base_path,
617        id = id
618    );
619    let mut local_var_req_builder =
620        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
621
622    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
623        local_var_req_builder =
624            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
625    }
626    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
627        let local_var_key = local_var_apikey.key.clone();
628        let local_var_value = match local_var_apikey.prefix {
629            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
630            None => local_var_key,
631        };
632        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
633    };
634
635    let local_var_req = local_var_req_builder.build()?;
636    let local_var_resp = local_var_client.execute(local_var_req).await?;
637
638    let local_var_status = local_var_resp.status();
639    let local_var_content = local_var_resp.text().await?;
640
641    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
642        Ok(())
643    } else {
644        let local_var_entity: Option<VirtualizationClusterGroupsDestroyError> =
645            serde_json::from_str(&local_var_content).ok();
646        let local_var_error = ResponseContent {
647            status: local_var_status,
648            content: local_var_content,
649            entity: local_var_entity,
650        };
651        Err(Error::ResponseError(local_var_error))
652    }
653}
654
655/// Get a list of cluster group objects.
656pub async fn virtualization_cluster_groups_list(
657    configuration: &configuration::Configuration,
658    contact: Option<Vec<i32>>,
659    contact__n: Option<Vec<i32>>,
660    contact_group: Option<Vec<String>>,
661    contact_group__n: Option<Vec<String>>,
662    contact_role: Option<Vec<i32>>,
663    contact_role__n: Option<Vec<i32>>,
664    created: Option<Vec<String>>,
665    created__empty: Option<Vec<String>>,
666    created__gt: Option<Vec<String>>,
667    created__gte: Option<Vec<String>>,
668    created__lt: Option<Vec<String>>,
669    created__lte: Option<Vec<String>>,
670    created__n: Option<Vec<String>>,
671    created_by_request: Option<&str>,
672    description: Option<Vec<String>>,
673    description__empty: Option<bool>,
674    description__ic: Option<Vec<String>>,
675    description__ie: Option<Vec<String>>,
676    description__iew: Option<Vec<String>>,
677    description__iregex: Option<Vec<String>>,
678    description__isw: Option<Vec<String>>,
679    description__n: Option<Vec<String>>,
680    description__nic: Option<Vec<String>>,
681    description__nie: Option<Vec<String>>,
682    description__niew: Option<Vec<String>>,
683    description__nisw: Option<Vec<String>>,
684    description__regex: Option<Vec<String>>,
685    id: Option<Vec<i32>>,
686    id__empty: Option<bool>,
687    id__gt: Option<Vec<i32>>,
688    id__gte: Option<Vec<i32>>,
689    id__lt: Option<Vec<i32>>,
690    id__lte: Option<Vec<i32>>,
691    id__n: Option<Vec<i32>>,
692    last_updated: Option<Vec<String>>,
693    last_updated__empty: Option<Vec<String>>,
694    last_updated__gt: Option<Vec<String>>,
695    last_updated__gte: Option<Vec<String>>,
696    last_updated__lt: Option<Vec<String>>,
697    last_updated__lte: Option<Vec<String>>,
698    last_updated__n: Option<Vec<String>>,
699    limit: Option<i32>,
700    modified_by_request: Option<&str>,
701    name: Option<Vec<String>>,
702    name__empty: Option<bool>,
703    name__ic: Option<Vec<String>>,
704    name__ie: Option<Vec<String>>,
705    name__iew: Option<Vec<String>>,
706    name__iregex: Option<Vec<String>>,
707    name__isw: Option<Vec<String>>,
708    name__n: Option<Vec<String>>,
709    name__nic: Option<Vec<String>>,
710    name__nie: Option<Vec<String>>,
711    name__niew: Option<Vec<String>>,
712    name__nisw: Option<Vec<String>>,
713    name__regex: Option<Vec<String>>,
714    offset: Option<i32>,
715    ordering: Option<&str>,
716    owner: Option<Vec<String>>,
717    owner__n: Option<Vec<String>>,
718    owner_group: Option<Vec<String>>,
719    owner_group__n: Option<Vec<String>>,
720    owner_group_id: Option<Vec<i32>>,
721    owner_group_id__n: Option<Vec<i32>>,
722    owner_id: Option<Vec<i32>>,
723    owner_id__n: Option<Vec<i32>>,
724    q: Option<&str>,
725    slug: Option<Vec<String>>,
726    slug__empty: Option<bool>,
727    slug__ic: Option<Vec<String>>,
728    slug__ie: Option<Vec<String>>,
729    slug__iew: Option<Vec<String>>,
730    slug__iregex: Option<Vec<String>>,
731    slug__isw: Option<Vec<String>>,
732    slug__n: Option<Vec<String>>,
733    slug__nic: Option<Vec<String>>,
734    slug__nie: Option<Vec<String>>,
735    slug__niew: Option<Vec<String>>,
736    slug__nisw: Option<Vec<String>>,
737    slug__regex: Option<Vec<String>>,
738    tag: Option<Vec<String>>,
739    tag__n: Option<Vec<String>>,
740    tag_id: Option<Vec<i32>>,
741    tag_id__n: Option<Vec<i32>>,
742    updated_by_request: Option<&str>,
743) -> Result<crate::models::PaginatedClusterGroupList, Error<VirtualizationClusterGroupsListError>> {
744    let local_var_configuration = configuration;
745
746    let local_var_client = &local_var_configuration.client;
747
748    let local_var_uri_str = format!(
749        "{}/api/virtualization/cluster-groups/",
750        local_var_configuration.base_path
751    );
752    let mut local_var_req_builder =
753        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
754
755    if let Some(ref local_var_str) = contact {
756        local_var_req_builder = match "multi" {
757            "multi" => local_var_req_builder.query(
758                &local_var_str
759                    .into_iter()
760                    .map(|p| ("contact".to_owned(), p.to_string()))
761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
762            ),
763            _ => local_var_req_builder.query(&[(
764                "contact",
765                &local_var_str
766                    .into_iter()
767                    .map(|p| p.to_string())
768                    .collect::<Vec<String>>()
769                    .join(",")
770                    .to_string(),
771            )]),
772        };
773    }
774    if let Some(ref local_var_str) = contact__n {
775        local_var_req_builder = match "multi" {
776            "multi" => local_var_req_builder.query(
777                &local_var_str
778                    .into_iter()
779                    .map(|p| ("contact__n".to_owned(), p.to_string()))
780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
781            ),
782            _ => local_var_req_builder.query(&[(
783                "contact__n",
784                &local_var_str
785                    .into_iter()
786                    .map(|p| p.to_string())
787                    .collect::<Vec<String>>()
788                    .join(",")
789                    .to_string(),
790            )]),
791        };
792    }
793    if let Some(ref local_var_str) = contact_group {
794        local_var_req_builder = match "multi" {
795            "multi" => local_var_req_builder.query(
796                &local_var_str
797                    .into_iter()
798                    .map(|p| ("contact_group".to_owned(), p.to_string()))
799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
800            ),
801            _ => local_var_req_builder.query(&[(
802                "contact_group",
803                &local_var_str
804                    .into_iter()
805                    .map(|p| p.to_string())
806                    .collect::<Vec<String>>()
807                    .join(",")
808                    .to_string(),
809            )]),
810        };
811    }
812    if let Some(ref local_var_str) = contact_group__n {
813        local_var_req_builder = match "multi" {
814            "multi" => local_var_req_builder.query(
815                &local_var_str
816                    .into_iter()
817                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
819            ),
820            _ => local_var_req_builder.query(&[(
821                "contact_group__n",
822                &local_var_str
823                    .into_iter()
824                    .map(|p| p.to_string())
825                    .collect::<Vec<String>>()
826                    .join(",")
827                    .to_string(),
828            )]),
829        };
830    }
831    if let Some(ref local_var_str) = contact_role {
832        local_var_req_builder = match "multi" {
833            "multi" => local_var_req_builder.query(
834                &local_var_str
835                    .into_iter()
836                    .map(|p| ("contact_role".to_owned(), p.to_string()))
837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
838            ),
839            _ => local_var_req_builder.query(&[(
840                "contact_role",
841                &local_var_str
842                    .into_iter()
843                    .map(|p| p.to_string())
844                    .collect::<Vec<String>>()
845                    .join(",")
846                    .to_string(),
847            )]),
848        };
849    }
850    if let Some(ref local_var_str) = contact_role__n {
851        local_var_req_builder = match "multi" {
852            "multi" => local_var_req_builder.query(
853                &local_var_str
854                    .into_iter()
855                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
857            ),
858            _ => local_var_req_builder.query(&[(
859                "contact_role__n",
860                &local_var_str
861                    .into_iter()
862                    .map(|p| p.to_string())
863                    .collect::<Vec<String>>()
864                    .join(",")
865                    .to_string(),
866            )]),
867        };
868    }
869    if let Some(ref local_var_str) = created {
870        local_var_req_builder = match "multi" {
871            "multi" => local_var_req_builder.query(
872                &local_var_str
873                    .into_iter()
874                    .map(|p| ("created".to_owned(), p.to_string()))
875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
876            ),
877            _ => local_var_req_builder.query(&[(
878                "created",
879                &local_var_str
880                    .into_iter()
881                    .map(|p| p.to_string())
882                    .collect::<Vec<String>>()
883                    .join(",")
884                    .to_string(),
885            )]),
886        };
887    }
888    if let Some(ref local_var_str) = created__empty {
889        local_var_req_builder = match "multi" {
890            "multi" => local_var_req_builder.query(
891                &local_var_str
892                    .into_iter()
893                    .map(|p| ("created__empty".to_owned(), p.to_string()))
894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
895            ),
896            _ => local_var_req_builder.query(&[(
897                "created__empty",
898                &local_var_str
899                    .into_iter()
900                    .map(|p| p.to_string())
901                    .collect::<Vec<String>>()
902                    .join(",")
903                    .to_string(),
904            )]),
905        };
906    }
907    if let Some(ref local_var_str) = created__gt {
908        local_var_req_builder = match "multi" {
909            "multi" => local_var_req_builder.query(
910                &local_var_str
911                    .into_iter()
912                    .map(|p| ("created__gt".to_owned(), p.to_string()))
913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
914            ),
915            _ => local_var_req_builder.query(&[(
916                "created__gt",
917                &local_var_str
918                    .into_iter()
919                    .map(|p| p.to_string())
920                    .collect::<Vec<String>>()
921                    .join(",")
922                    .to_string(),
923            )]),
924        };
925    }
926    if let Some(ref local_var_str) = created__gte {
927        local_var_req_builder = match "multi" {
928            "multi" => local_var_req_builder.query(
929                &local_var_str
930                    .into_iter()
931                    .map(|p| ("created__gte".to_owned(), p.to_string()))
932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
933            ),
934            _ => local_var_req_builder.query(&[(
935                "created__gte",
936                &local_var_str
937                    .into_iter()
938                    .map(|p| p.to_string())
939                    .collect::<Vec<String>>()
940                    .join(",")
941                    .to_string(),
942            )]),
943        };
944    }
945    if let Some(ref local_var_str) = created__lt {
946        local_var_req_builder = match "multi" {
947            "multi" => local_var_req_builder.query(
948                &local_var_str
949                    .into_iter()
950                    .map(|p| ("created__lt".to_owned(), p.to_string()))
951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
952            ),
953            _ => local_var_req_builder.query(&[(
954                "created__lt",
955                &local_var_str
956                    .into_iter()
957                    .map(|p| p.to_string())
958                    .collect::<Vec<String>>()
959                    .join(",")
960                    .to_string(),
961            )]),
962        };
963    }
964    if let Some(ref local_var_str) = created__lte {
965        local_var_req_builder = match "multi" {
966            "multi" => local_var_req_builder.query(
967                &local_var_str
968                    .into_iter()
969                    .map(|p| ("created__lte".to_owned(), p.to_string()))
970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
971            ),
972            _ => local_var_req_builder.query(&[(
973                "created__lte",
974                &local_var_str
975                    .into_iter()
976                    .map(|p| p.to_string())
977                    .collect::<Vec<String>>()
978                    .join(",")
979                    .to_string(),
980            )]),
981        };
982    }
983    if let Some(ref local_var_str) = created__n {
984        local_var_req_builder = match "multi" {
985            "multi" => local_var_req_builder.query(
986                &local_var_str
987                    .into_iter()
988                    .map(|p| ("created__n".to_owned(), p.to_string()))
989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
990            ),
991            _ => local_var_req_builder.query(&[(
992                "created__n",
993                &local_var_str
994                    .into_iter()
995                    .map(|p| p.to_string())
996                    .collect::<Vec<String>>()
997                    .join(",")
998                    .to_string(),
999            )]),
1000        };
1001    }
1002    if let Some(ref local_var_str) = created_by_request {
1003        local_var_req_builder =
1004            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1005    }
1006    if let Some(ref local_var_str) = description {
1007        local_var_req_builder = match "multi" {
1008            "multi" => local_var_req_builder.query(
1009                &local_var_str
1010                    .into_iter()
1011                    .map(|p| ("description".to_owned(), p.to_string()))
1012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1013            ),
1014            _ => local_var_req_builder.query(&[(
1015                "description",
1016                &local_var_str
1017                    .into_iter()
1018                    .map(|p| p.to_string())
1019                    .collect::<Vec<String>>()
1020                    .join(",")
1021                    .to_string(),
1022            )]),
1023        };
1024    }
1025    if let Some(ref local_var_str) = description__empty {
1026        local_var_req_builder =
1027            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1028    }
1029    if let Some(ref local_var_str) = description__ic {
1030        local_var_req_builder = match "multi" {
1031            "multi" => local_var_req_builder.query(
1032                &local_var_str
1033                    .into_iter()
1034                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1036            ),
1037            _ => local_var_req_builder.query(&[(
1038                "description__ic",
1039                &local_var_str
1040                    .into_iter()
1041                    .map(|p| p.to_string())
1042                    .collect::<Vec<String>>()
1043                    .join(",")
1044                    .to_string(),
1045            )]),
1046        };
1047    }
1048    if let Some(ref local_var_str) = description__ie {
1049        local_var_req_builder = match "multi" {
1050            "multi" => local_var_req_builder.query(
1051                &local_var_str
1052                    .into_iter()
1053                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1055            ),
1056            _ => local_var_req_builder.query(&[(
1057                "description__ie",
1058                &local_var_str
1059                    .into_iter()
1060                    .map(|p| p.to_string())
1061                    .collect::<Vec<String>>()
1062                    .join(",")
1063                    .to_string(),
1064            )]),
1065        };
1066    }
1067    if let Some(ref local_var_str) = description__iew {
1068        local_var_req_builder = match "multi" {
1069            "multi" => local_var_req_builder.query(
1070                &local_var_str
1071                    .into_iter()
1072                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1074            ),
1075            _ => local_var_req_builder.query(&[(
1076                "description__iew",
1077                &local_var_str
1078                    .into_iter()
1079                    .map(|p| p.to_string())
1080                    .collect::<Vec<String>>()
1081                    .join(",")
1082                    .to_string(),
1083            )]),
1084        };
1085    }
1086    if let Some(ref local_var_str) = description__iregex {
1087        local_var_req_builder = match "multi" {
1088            "multi" => local_var_req_builder.query(
1089                &local_var_str
1090                    .into_iter()
1091                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1093            ),
1094            _ => local_var_req_builder.query(&[(
1095                "description__iregex",
1096                &local_var_str
1097                    .into_iter()
1098                    .map(|p| p.to_string())
1099                    .collect::<Vec<String>>()
1100                    .join(",")
1101                    .to_string(),
1102            )]),
1103        };
1104    }
1105    if let Some(ref local_var_str) = description__isw {
1106        local_var_req_builder = match "multi" {
1107            "multi" => local_var_req_builder.query(
1108                &local_var_str
1109                    .into_iter()
1110                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1112            ),
1113            _ => local_var_req_builder.query(&[(
1114                "description__isw",
1115                &local_var_str
1116                    .into_iter()
1117                    .map(|p| p.to_string())
1118                    .collect::<Vec<String>>()
1119                    .join(",")
1120                    .to_string(),
1121            )]),
1122        };
1123    }
1124    if let Some(ref local_var_str) = description__n {
1125        local_var_req_builder = match "multi" {
1126            "multi" => local_var_req_builder.query(
1127                &local_var_str
1128                    .into_iter()
1129                    .map(|p| ("description__n".to_owned(), p.to_string()))
1130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1131            ),
1132            _ => local_var_req_builder.query(&[(
1133                "description__n",
1134                &local_var_str
1135                    .into_iter()
1136                    .map(|p| p.to_string())
1137                    .collect::<Vec<String>>()
1138                    .join(",")
1139                    .to_string(),
1140            )]),
1141        };
1142    }
1143    if let Some(ref local_var_str) = description__nic {
1144        local_var_req_builder = match "multi" {
1145            "multi" => local_var_req_builder.query(
1146                &local_var_str
1147                    .into_iter()
1148                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1150            ),
1151            _ => local_var_req_builder.query(&[(
1152                "description__nic",
1153                &local_var_str
1154                    .into_iter()
1155                    .map(|p| p.to_string())
1156                    .collect::<Vec<String>>()
1157                    .join(",")
1158                    .to_string(),
1159            )]),
1160        };
1161    }
1162    if let Some(ref local_var_str) = description__nie {
1163        local_var_req_builder = match "multi" {
1164            "multi" => local_var_req_builder.query(
1165                &local_var_str
1166                    .into_iter()
1167                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1169            ),
1170            _ => local_var_req_builder.query(&[(
1171                "description__nie",
1172                &local_var_str
1173                    .into_iter()
1174                    .map(|p| p.to_string())
1175                    .collect::<Vec<String>>()
1176                    .join(",")
1177                    .to_string(),
1178            )]),
1179        };
1180    }
1181    if let Some(ref local_var_str) = description__niew {
1182        local_var_req_builder = match "multi" {
1183            "multi" => local_var_req_builder.query(
1184                &local_var_str
1185                    .into_iter()
1186                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1188            ),
1189            _ => local_var_req_builder.query(&[(
1190                "description__niew",
1191                &local_var_str
1192                    .into_iter()
1193                    .map(|p| p.to_string())
1194                    .collect::<Vec<String>>()
1195                    .join(",")
1196                    .to_string(),
1197            )]),
1198        };
1199    }
1200    if let Some(ref local_var_str) = description__nisw {
1201        local_var_req_builder = match "multi" {
1202            "multi" => local_var_req_builder.query(
1203                &local_var_str
1204                    .into_iter()
1205                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1207            ),
1208            _ => local_var_req_builder.query(&[(
1209                "description__nisw",
1210                &local_var_str
1211                    .into_iter()
1212                    .map(|p| p.to_string())
1213                    .collect::<Vec<String>>()
1214                    .join(",")
1215                    .to_string(),
1216            )]),
1217        };
1218    }
1219    if let Some(ref local_var_str) = description__regex {
1220        local_var_req_builder = match "multi" {
1221            "multi" => local_var_req_builder.query(
1222                &local_var_str
1223                    .into_iter()
1224                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1226            ),
1227            _ => local_var_req_builder.query(&[(
1228                "description__regex",
1229                &local_var_str
1230                    .into_iter()
1231                    .map(|p| p.to_string())
1232                    .collect::<Vec<String>>()
1233                    .join(",")
1234                    .to_string(),
1235            )]),
1236        };
1237    }
1238    if let Some(ref local_var_str) = id {
1239        local_var_req_builder = match "multi" {
1240            "multi" => local_var_req_builder.query(
1241                &local_var_str
1242                    .into_iter()
1243                    .map(|p| ("id".to_owned(), p.to_string()))
1244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1245            ),
1246            _ => local_var_req_builder.query(&[(
1247                "id",
1248                &local_var_str
1249                    .into_iter()
1250                    .map(|p| p.to_string())
1251                    .collect::<Vec<String>>()
1252                    .join(",")
1253                    .to_string(),
1254            )]),
1255        };
1256    }
1257    if let Some(ref local_var_str) = id__empty {
1258        local_var_req_builder =
1259            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1260    }
1261    if let Some(ref local_var_str) = id__gt {
1262        local_var_req_builder = match "multi" {
1263            "multi" => local_var_req_builder.query(
1264                &local_var_str
1265                    .into_iter()
1266                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1268            ),
1269            _ => local_var_req_builder.query(&[(
1270                "id__gt",
1271                &local_var_str
1272                    .into_iter()
1273                    .map(|p| p.to_string())
1274                    .collect::<Vec<String>>()
1275                    .join(",")
1276                    .to_string(),
1277            )]),
1278        };
1279    }
1280    if let Some(ref local_var_str) = id__gte {
1281        local_var_req_builder = match "multi" {
1282            "multi" => local_var_req_builder.query(
1283                &local_var_str
1284                    .into_iter()
1285                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1287            ),
1288            _ => local_var_req_builder.query(&[(
1289                "id__gte",
1290                &local_var_str
1291                    .into_iter()
1292                    .map(|p| p.to_string())
1293                    .collect::<Vec<String>>()
1294                    .join(",")
1295                    .to_string(),
1296            )]),
1297        };
1298    }
1299    if let Some(ref local_var_str) = id__lt {
1300        local_var_req_builder = match "multi" {
1301            "multi" => local_var_req_builder.query(
1302                &local_var_str
1303                    .into_iter()
1304                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1306            ),
1307            _ => local_var_req_builder.query(&[(
1308                "id__lt",
1309                &local_var_str
1310                    .into_iter()
1311                    .map(|p| p.to_string())
1312                    .collect::<Vec<String>>()
1313                    .join(",")
1314                    .to_string(),
1315            )]),
1316        };
1317    }
1318    if let Some(ref local_var_str) = id__lte {
1319        local_var_req_builder = match "multi" {
1320            "multi" => local_var_req_builder.query(
1321                &local_var_str
1322                    .into_iter()
1323                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1325            ),
1326            _ => local_var_req_builder.query(&[(
1327                "id__lte",
1328                &local_var_str
1329                    .into_iter()
1330                    .map(|p| p.to_string())
1331                    .collect::<Vec<String>>()
1332                    .join(",")
1333                    .to_string(),
1334            )]),
1335        };
1336    }
1337    if let Some(ref local_var_str) = id__n {
1338        local_var_req_builder = match "multi" {
1339            "multi" => local_var_req_builder.query(
1340                &local_var_str
1341                    .into_iter()
1342                    .map(|p| ("id__n".to_owned(), p.to_string()))
1343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1344            ),
1345            _ => local_var_req_builder.query(&[(
1346                "id__n",
1347                &local_var_str
1348                    .into_iter()
1349                    .map(|p| p.to_string())
1350                    .collect::<Vec<String>>()
1351                    .join(",")
1352                    .to_string(),
1353            )]),
1354        };
1355    }
1356    if let Some(ref local_var_str) = last_updated {
1357        local_var_req_builder = match "multi" {
1358            "multi" => local_var_req_builder.query(
1359                &local_var_str
1360                    .into_iter()
1361                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1363            ),
1364            _ => local_var_req_builder.query(&[(
1365                "last_updated",
1366                &local_var_str
1367                    .into_iter()
1368                    .map(|p| p.to_string())
1369                    .collect::<Vec<String>>()
1370                    .join(",")
1371                    .to_string(),
1372            )]),
1373        };
1374    }
1375    if let Some(ref local_var_str) = last_updated__empty {
1376        local_var_req_builder = match "multi" {
1377            "multi" => local_var_req_builder.query(
1378                &local_var_str
1379                    .into_iter()
1380                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1382            ),
1383            _ => local_var_req_builder.query(&[(
1384                "last_updated__empty",
1385                &local_var_str
1386                    .into_iter()
1387                    .map(|p| p.to_string())
1388                    .collect::<Vec<String>>()
1389                    .join(",")
1390                    .to_string(),
1391            )]),
1392        };
1393    }
1394    if let Some(ref local_var_str) = last_updated__gt {
1395        local_var_req_builder = match "multi" {
1396            "multi" => local_var_req_builder.query(
1397                &local_var_str
1398                    .into_iter()
1399                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1401            ),
1402            _ => local_var_req_builder.query(&[(
1403                "last_updated__gt",
1404                &local_var_str
1405                    .into_iter()
1406                    .map(|p| p.to_string())
1407                    .collect::<Vec<String>>()
1408                    .join(",")
1409                    .to_string(),
1410            )]),
1411        };
1412    }
1413    if let Some(ref local_var_str) = last_updated__gte {
1414        local_var_req_builder = match "multi" {
1415            "multi" => local_var_req_builder.query(
1416                &local_var_str
1417                    .into_iter()
1418                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1420            ),
1421            _ => local_var_req_builder.query(&[(
1422                "last_updated__gte",
1423                &local_var_str
1424                    .into_iter()
1425                    .map(|p| p.to_string())
1426                    .collect::<Vec<String>>()
1427                    .join(",")
1428                    .to_string(),
1429            )]),
1430        };
1431    }
1432    if let Some(ref local_var_str) = last_updated__lt {
1433        local_var_req_builder = match "multi" {
1434            "multi" => local_var_req_builder.query(
1435                &local_var_str
1436                    .into_iter()
1437                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1439            ),
1440            _ => local_var_req_builder.query(&[(
1441                "last_updated__lt",
1442                &local_var_str
1443                    .into_iter()
1444                    .map(|p| p.to_string())
1445                    .collect::<Vec<String>>()
1446                    .join(",")
1447                    .to_string(),
1448            )]),
1449        };
1450    }
1451    if let Some(ref local_var_str) = last_updated__lte {
1452        local_var_req_builder = match "multi" {
1453            "multi" => local_var_req_builder.query(
1454                &local_var_str
1455                    .into_iter()
1456                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1458            ),
1459            _ => local_var_req_builder.query(&[(
1460                "last_updated__lte",
1461                &local_var_str
1462                    .into_iter()
1463                    .map(|p| p.to_string())
1464                    .collect::<Vec<String>>()
1465                    .join(",")
1466                    .to_string(),
1467            )]),
1468        };
1469    }
1470    if let Some(ref local_var_str) = last_updated__n {
1471        local_var_req_builder = match "multi" {
1472            "multi" => local_var_req_builder.query(
1473                &local_var_str
1474                    .into_iter()
1475                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1477            ),
1478            _ => local_var_req_builder.query(&[(
1479                "last_updated__n",
1480                &local_var_str
1481                    .into_iter()
1482                    .map(|p| p.to_string())
1483                    .collect::<Vec<String>>()
1484                    .join(",")
1485                    .to_string(),
1486            )]),
1487        };
1488    }
1489    if let Some(ref local_var_str) = limit {
1490        local_var_req_builder =
1491            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1492    }
1493    if let Some(ref local_var_str) = modified_by_request {
1494        local_var_req_builder =
1495            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1496    }
1497    if let Some(ref local_var_str) = name {
1498        local_var_req_builder = match "multi" {
1499            "multi" => local_var_req_builder.query(
1500                &local_var_str
1501                    .into_iter()
1502                    .map(|p| ("name".to_owned(), p.to_string()))
1503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1504            ),
1505            _ => local_var_req_builder.query(&[(
1506                "name",
1507                &local_var_str
1508                    .into_iter()
1509                    .map(|p| p.to_string())
1510                    .collect::<Vec<String>>()
1511                    .join(",")
1512                    .to_string(),
1513            )]),
1514        };
1515    }
1516    if let Some(ref local_var_str) = name__empty {
1517        local_var_req_builder =
1518            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1519    }
1520    if let Some(ref local_var_str) = name__ic {
1521        local_var_req_builder = match "multi" {
1522            "multi" => local_var_req_builder.query(
1523                &local_var_str
1524                    .into_iter()
1525                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1527            ),
1528            _ => local_var_req_builder.query(&[(
1529                "name__ic",
1530                &local_var_str
1531                    .into_iter()
1532                    .map(|p| p.to_string())
1533                    .collect::<Vec<String>>()
1534                    .join(",")
1535                    .to_string(),
1536            )]),
1537        };
1538    }
1539    if let Some(ref local_var_str) = name__ie {
1540        local_var_req_builder = match "multi" {
1541            "multi" => local_var_req_builder.query(
1542                &local_var_str
1543                    .into_iter()
1544                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1546            ),
1547            _ => local_var_req_builder.query(&[(
1548                "name__ie",
1549                &local_var_str
1550                    .into_iter()
1551                    .map(|p| p.to_string())
1552                    .collect::<Vec<String>>()
1553                    .join(",")
1554                    .to_string(),
1555            )]),
1556        };
1557    }
1558    if let Some(ref local_var_str) = name__iew {
1559        local_var_req_builder = match "multi" {
1560            "multi" => local_var_req_builder.query(
1561                &local_var_str
1562                    .into_iter()
1563                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1565            ),
1566            _ => local_var_req_builder.query(&[(
1567                "name__iew",
1568                &local_var_str
1569                    .into_iter()
1570                    .map(|p| p.to_string())
1571                    .collect::<Vec<String>>()
1572                    .join(",")
1573                    .to_string(),
1574            )]),
1575        };
1576    }
1577    if let Some(ref local_var_str) = name__iregex {
1578        local_var_req_builder = match "multi" {
1579            "multi" => local_var_req_builder.query(
1580                &local_var_str
1581                    .into_iter()
1582                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
1583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1584            ),
1585            _ => local_var_req_builder.query(&[(
1586                "name__iregex",
1587                &local_var_str
1588                    .into_iter()
1589                    .map(|p| p.to_string())
1590                    .collect::<Vec<String>>()
1591                    .join(",")
1592                    .to_string(),
1593            )]),
1594        };
1595    }
1596    if let Some(ref local_var_str) = name__isw {
1597        local_var_req_builder = match "multi" {
1598            "multi" => local_var_req_builder.query(
1599                &local_var_str
1600                    .into_iter()
1601                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1603            ),
1604            _ => local_var_req_builder.query(&[(
1605                "name__isw",
1606                &local_var_str
1607                    .into_iter()
1608                    .map(|p| p.to_string())
1609                    .collect::<Vec<String>>()
1610                    .join(",")
1611                    .to_string(),
1612            )]),
1613        };
1614    }
1615    if let Some(ref local_var_str) = name__n {
1616        local_var_req_builder = match "multi" {
1617            "multi" => local_var_req_builder.query(
1618                &local_var_str
1619                    .into_iter()
1620                    .map(|p| ("name__n".to_owned(), p.to_string()))
1621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1622            ),
1623            _ => local_var_req_builder.query(&[(
1624                "name__n",
1625                &local_var_str
1626                    .into_iter()
1627                    .map(|p| p.to_string())
1628                    .collect::<Vec<String>>()
1629                    .join(",")
1630                    .to_string(),
1631            )]),
1632        };
1633    }
1634    if let Some(ref local_var_str) = name__nic {
1635        local_var_req_builder = match "multi" {
1636            "multi" => local_var_req_builder.query(
1637                &local_var_str
1638                    .into_iter()
1639                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1641            ),
1642            _ => local_var_req_builder.query(&[(
1643                "name__nic",
1644                &local_var_str
1645                    .into_iter()
1646                    .map(|p| p.to_string())
1647                    .collect::<Vec<String>>()
1648                    .join(",")
1649                    .to_string(),
1650            )]),
1651        };
1652    }
1653    if let Some(ref local_var_str) = name__nie {
1654        local_var_req_builder = match "multi" {
1655            "multi" => local_var_req_builder.query(
1656                &local_var_str
1657                    .into_iter()
1658                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1660            ),
1661            _ => local_var_req_builder.query(&[(
1662                "name__nie",
1663                &local_var_str
1664                    .into_iter()
1665                    .map(|p| p.to_string())
1666                    .collect::<Vec<String>>()
1667                    .join(",")
1668                    .to_string(),
1669            )]),
1670        };
1671    }
1672    if let Some(ref local_var_str) = name__niew {
1673        local_var_req_builder = match "multi" {
1674            "multi" => local_var_req_builder.query(
1675                &local_var_str
1676                    .into_iter()
1677                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1679            ),
1680            _ => local_var_req_builder.query(&[(
1681                "name__niew",
1682                &local_var_str
1683                    .into_iter()
1684                    .map(|p| p.to_string())
1685                    .collect::<Vec<String>>()
1686                    .join(",")
1687                    .to_string(),
1688            )]),
1689        };
1690    }
1691    if let Some(ref local_var_str) = name__nisw {
1692        local_var_req_builder = match "multi" {
1693            "multi" => local_var_req_builder.query(
1694                &local_var_str
1695                    .into_iter()
1696                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1698            ),
1699            _ => local_var_req_builder.query(&[(
1700                "name__nisw",
1701                &local_var_str
1702                    .into_iter()
1703                    .map(|p| p.to_string())
1704                    .collect::<Vec<String>>()
1705                    .join(",")
1706                    .to_string(),
1707            )]),
1708        };
1709    }
1710    if let Some(ref local_var_str) = name__regex {
1711        local_var_req_builder = match "multi" {
1712            "multi" => local_var_req_builder.query(
1713                &local_var_str
1714                    .into_iter()
1715                    .map(|p| ("name__regex".to_owned(), p.to_string()))
1716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1717            ),
1718            _ => local_var_req_builder.query(&[(
1719                "name__regex",
1720                &local_var_str
1721                    .into_iter()
1722                    .map(|p| p.to_string())
1723                    .collect::<Vec<String>>()
1724                    .join(",")
1725                    .to_string(),
1726            )]),
1727        };
1728    }
1729    if let Some(ref local_var_str) = offset {
1730        local_var_req_builder =
1731            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1732    }
1733    if let Some(ref local_var_str) = ordering {
1734        local_var_req_builder =
1735            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1736    }
1737    if let Some(ref local_var_str) = owner {
1738        local_var_req_builder = match "multi" {
1739            "multi" => local_var_req_builder.query(
1740                &local_var_str
1741                    .into_iter()
1742                    .map(|p| ("owner".to_owned(), p.to_string()))
1743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1744            ),
1745            _ => local_var_req_builder.query(&[(
1746                "owner",
1747                &local_var_str
1748                    .into_iter()
1749                    .map(|p| p.to_string())
1750                    .collect::<Vec<String>>()
1751                    .join(",")
1752                    .to_string(),
1753            )]),
1754        };
1755    }
1756    if let Some(ref local_var_str) = owner__n {
1757        local_var_req_builder = match "multi" {
1758            "multi" => local_var_req_builder.query(
1759                &local_var_str
1760                    .into_iter()
1761                    .map(|p| ("owner__n".to_owned(), p.to_string()))
1762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1763            ),
1764            _ => local_var_req_builder.query(&[(
1765                "owner__n",
1766                &local_var_str
1767                    .into_iter()
1768                    .map(|p| p.to_string())
1769                    .collect::<Vec<String>>()
1770                    .join(",")
1771                    .to_string(),
1772            )]),
1773        };
1774    }
1775    if let Some(ref local_var_str) = owner_group {
1776        local_var_req_builder = match "multi" {
1777            "multi" => local_var_req_builder.query(
1778                &local_var_str
1779                    .into_iter()
1780                    .map(|p| ("owner_group".to_owned(), p.to_string()))
1781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1782            ),
1783            _ => local_var_req_builder.query(&[(
1784                "owner_group",
1785                &local_var_str
1786                    .into_iter()
1787                    .map(|p| p.to_string())
1788                    .collect::<Vec<String>>()
1789                    .join(",")
1790                    .to_string(),
1791            )]),
1792        };
1793    }
1794    if let Some(ref local_var_str) = owner_group__n {
1795        local_var_req_builder = match "multi" {
1796            "multi" => local_var_req_builder.query(
1797                &local_var_str
1798                    .into_iter()
1799                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
1800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1801            ),
1802            _ => local_var_req_builder.query(&[(
1803                "owner_group__n",
1804                &local_var_str
1805                    .into_iter()
1806                    .map(|p| p.to_string())
1807                    .collect::<Vec<String>>()
1808                    .join(",")
1809                    .to_string(),
1810            )]),
1811        };
1812    }
1813    if let Some(ref local_var_str) = owner_group_id {
1814        local_var_req_builder = match "multi" {
1815            "multi" => local_var_req_builder.query(
1816                &local_var_str
1817                    .into_iter()
1818                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
1819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1820            ),
1821            _ => local_var_req_builder.query(&[(
1822                "owner_group_id",
1823                &local_var_str
1824                    .into_iter()
1825                    .map(|p| p.to_string())
1826                    .collect::<Vec<String>>()
1827                    .join(",")
1828                    .to_string(),
1829            )]),
1830        };
1831    }
1832    if let Some(ref local_var_str) = owner_group_id__n {
1833        local_var_req_builder = match "multi" {
1834            "multi" => local_var_req_builder.query(
1835                &local_var_str
1836                    .into_iter()
1837                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
1838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1839            ),
1840            _ => local_var_req_builder.query(&[(
1841                "owner_group_id__n",
1842                &local_var_str
1843                    .into_iter()
1844                    .map(|p| p.to_string())
1845                    .collect::<Vec<String>>()
1846                    .join(",")
1847                    .to_string(),
1848            )]),
1849        };
1850    }
1851    if let Some(ref local_var_str) = owner_id {
1852        local_var_req_builder = match "multi" {
1853            "multi" => local_var_req_builder.query(
1854                &local_var_str
1855                    .into_iter()
1856                    .map(|p| ("owner_id".to_owned(), p.to_string()))
1857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1858            ),
1859            _ => local_var_req_builder.query(&[(
1860                "owner_id",
1861                &local_var_str
1862                    .into_iter()
1863                    .map(|p| p.to_string())
1864                    .collect::<Vec<String>>()
1865                    .join(",")
1866                    .to_string(),
1867            )]),
1868        };
1869    }
1870    if let Some(ref local_var_str) = owner_id__n {
1871        local_var_req_builder = match "multi" {
1872            "multi" => local_var_req_builder.query(
1873                &local_var_str
1874                    .into_iter()
1875                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
1876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1877            ),
1878            _ => local_var_req_builder.query(&[(
1879                "owner_id__n",
1880                &local_var_str
1881                    .into_iter()
1882                    .map(|p| p.to_string())
1883                    .collect::<Vec<String>>()
1884                    .join(",")
1885                    .to_string(),
1886            )]),
1887        };
1888    }
1889    if let Some(ref local_var_str) = q {
1890        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1891    }
1892    if let Some(ref local_var_str) = slug {
1893        local_var_req_builder = match "multi" {
1894            "multi" => local_var_req_builder.query(
1895                &local_var_str
1896                    .into_iter()
1897                    .map(|p| ("slug".to_owned(), p.to_string()))
1898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1899            ),
1900            _ => local_var_req_builder.query(&[(
1901                "slug",
1902                &local_var_str
1903                    .into_iter()
1904                    .map(|p| p.to_string())
1905                    .collect::<Vec<String>>()
1906                    .join(",")
1907                    .to_string(),
1908            )]),
1909        };
1910    }
1911    if let Some(ref local_var_str) = slug__empty {
1912        local_var_req_builder =
1913            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
1914    }
1915    if let Some(ref local_var_str) = slug__ic {
1916        local_var_req_builder = match "multi" {
1917            "multi" => local_var_req_builder.query(
1918                &local_var_str
1919                    .into_iter()
1920                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
1921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1922            ),
1923            _ => local_var_req_builder.query(&[(
1924                "slug__ic",
1925                &local_var_str
1926                    .into_iter()
1927                    .map(|p| p.to_string())
1928                    .collect::<Vec<String>>()
1929                    .join(",")
1930                    .to_string(),
1931            )]),
1932        };
1933    }
1934    if let Some(ref local_var_str) = slug__ie {
1935        local_var_req_builder = match "multi" {
1936            "multi" => local_var_req_builder.query(
1937                &local_var_str
1938                    .into_iter()
1939                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
1940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1941            ),
1942            _ => local_var_req_builder.query(&[(
1943                "slug__ie",
1944                &local_var_str
1945                    .into_iter()
1946                    .map(|p| p.to_string())
1947                    .collect::<Vec<String>>()
1948                    .join(",")
1949                    .to_string(),
1950            )]),
1951        };
1952    }
1953    if let Some(ref local_var_str) = slug__iew {
1954        local_var_req_builder = match "multi" {
1955            "multi" => local_var_req_builder.query(
1956                &local_var_str
1957                    .into_iter()
1958                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
1959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1960            ),
1961            _ => local_var_req_builder.query(&[(
1962                "slug__iew",
1963                &local_var_str
1964                    .into_iter()
1965                    .map(|p| p.to_string())
1966                    .collect::<Vec<String>>()
1967                    .join(",")
1968                    .to_string(),
1969            )]),
1970        };
1971    }
1972    if let Some(ref local_var_str) = slug__iregex {
1973        local_var_req_builder = match "multi" {
1974            "multi" => local_var_req_builder.query(
1975                &local_var_str
1976                    .into_iter()
1977                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
1978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1979            ),
1980            _ => local_var_req_builder.query(&[(
1981                "slug__iregex",
1982                &local_var_str
1983                    .into_iter()
1984                    .map(|p| p.to_string())
1985                    .collect::<Vec<String>>()
1986                    .join(",")
1987                    .to_string(),
1988            )]),
1989        };
1990    }
1991    if let Some(ref local_var_str) = slug__isw {
1992        local_var_req_builder = match "multi" {
1993            "multi" => local_var_req_builder.query(
1994                &local_var_str
1995                    .into_iter()
1996                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
1997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1998            ),
1999            _ => local_var_req_builder.query(&[(
2000                "slug__isw",
2001                &local_var_str
2002                    .into_iter()
2003                    .map(|p| p.to_string())
2004                    .collect::<Vec<String>>()
2005                    .join(",")
2006                    .to_string(),
2007            )]),
2008        };
2009    }
2010    if let Some(ref local_var_str) = slug__n {
2011        local_var_req_builder = match "multi" {
2012            "multi" => local_var_req_builder.query(
2013                &local_var_str
2014                    .into_iter()
2015                    .map(|p| ("slug__n".to_owned(), p.to_string()))
2016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2017            ),
2018            _ => local_var_req_builder.query(&[(
2019                "slug__n",
2020                &local_var_str
2021                    .into_iter()
2022                    .map(|p| p.to_string())
2023                    .collect::<Vec<String>>()
2024                    .join(",")
2025                    .to_string(),
2026            )]),
2027        };
2028    }
2029    if let Some(ref local_var_str) = slug__nic {
2030        local_var_req_builder = match "multi" {
2031            "multi" => local_var_req_builder.query(
2032                &local_var_str
2033                    .into_iter()
2034                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
2035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2036            ),
2037            _ => local_var_req_builder.query(&[(
2038                "slug__nic",
2039                &local_var_str
2040                    .into_iter()
2041                    .map(|p| p.to_string())
2042                    .collect::<Vec<String>>()
2043                    .join(",")
2044                    .to_string(),
2045            )]),
2046        };
2047    }
2048    if let Some(ref local_var_str) = slug__nie {
2049        local_var_req_builder = match "multi" {
2050            "multi" => local_var_req_builder.query(
2051                &local_var_str
2052                    .into_iter()
2053                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
2054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2055            ),
2056            _ => local_var_req_builder.query(&[(
2057                "slug__nie",
2058                &local_var_str
2059                    .into_iter()
2060                    .map(|p| p.to_string())
2061                    .collect::<Vec<String>>()
2062                    .join(",")
2063                    .to_string(),
2064            )]),
2065        };
2066    }
2067    if let Some(ref local_var_str) = slug__niew {
2068        local_var_req_builder = match "multi" {
2069            "multi" => local_var_req_builder.query(
2070                &local_var_str
2071                    .into_iter()
2072                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
2073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2074            ),
2075            _ => local_var_req_builder.query(&[(
2076                "slug__niew",
2077                &local_var_str
2078                    .into_iter()
2079                    .map(|p| p.to_string())
2080                    .collect::<Vec<String>>()
2081                    .join(",")
2082                    .to_string(),
2083            )]),
2084        };
2085    }
2086    if let Some(ref local_var_str) = slug__nisw {
2087        local_var_req_builder = match "multi" {
2088            "multi" => local_var_req_builder.query(
2089                &local_var_str
2090                    .into_iter()
2091                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
2092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2093            ),
2094            _ => local_var_req_builder.query(&[(
2095                "slug__nisw",
2096                &local_var_str
2097                    .into_iter()
2098                    .map(|p| p.to_string())
2099                    .collect::<Vec<String>>()
2100                    .join(",")
2101                    .to_string(),
2102            )]),
2103        };
2104    }
2105    if let Some(ref local_var_str) = slug__regex {
2106        local_var_req_builder = match "multi" {
2107            "multi" => local_var_req_builder.query(
2108                &local_var_str
2109                    .into_iter()
2110                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
2111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2112            ),
2113            _ => local_var_req_builder.query(&[(
2114                "slug__regex",
2115                &local_var_str
2116                    .into_iter()
2117                    .map(|p| p.to_string())
2118                    .collect::<Vec<String>>()
2119                    .join(",")
2120                    .to_string(),
2121            )]),
2122        };
2123    }
2124    if let Some(ref local_var_str) = tag {
2125        local_var_req_builder = match "multi" {
2126            "multi" => local_var_req_builder.query(
2127                &local_var_str
2128                    .into_iter()
2129                    .map(|p| ("tag".to_owned(), p.to_string()))
2130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2131            ),
2132            _ => local_var_req_builder.query(&[(
2133                "tag",
2134                &local_var_str
2135                    .into_iter()
2136                    .map(|p| p.to_string())
2137                    .collect::<Vec<String>>()
2138                    .join(",")
2139                    .to_string(),
2140            )]),
2141        };
2142    }
2143    if let Some(ref local_var_str) = tag__n {
2144        local_var_req_builder = match "multi" {
2145            "multi" => local_var_req_builder.query(
2146                &local_var_str
2147                    .into_iter()
2148                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2150            ),
2151            _ => local_var_req_builder.query(&[(
2152                "tag__n",
2153                &local_var_str
2154                    .into_iter()
2155                    .map(|p| p.to_string())
2156                    .collect::<Vec<String>>()
2157                    .join(",")
2158                    .to_string(),
2159            )]),
2160        };
2161    }
2162    if let Some(ref local_var_str) = tag_id {
2163        local_var_req_builder = match "multi" {
2164            "multi" => local_var_req_builder.query(
2165                &local_var_str
2166                    .into_iter()
2167                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2169            ),
2170            _ => local_var_req_builder.query(&[(
2171                "tag_id",
2172                &local_var_str
2173                    .into_iter()
2174                    .map(|p| p.to_string())
2175                    .collect::<Vec<String>>()
2176                    .join(",")
2177                    .to_string(),
2178            )]),
2179        };
2180    }
2181    if let Some(ref local_var_str) = tag_id__n {
2182        local_var_req_builder = match "multi" {
2183            "multi" => local_var_req_builder.query(
2184                &local_var_str
2185                    .into_iter()
2186                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2188            ),
2189            _ => local_var_req_builder.query(&[(
2190                "tag_id__n",
2191                &local_var_str
2192                    .into_iter()
2193                    .map(|p| p.to_string())
2194                    .collect::<Vec<String>>()
2195                    .join(",")
2196                    .to_string(),
2197            )]),
2198        };
2199    }
2200    if let Some(ref local_var_str) = updated_by_request {
2201        local_var_req_builder =
2202            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2203    }
2204    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2205        local_var_req_builder =
2206            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2207    }
2208    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2209        let local_var_key = local_var_apikey.key.clone();
2210        let local_var_value = match local_var_apikey.prefix {
2211            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2212            None => local_var_key,
2213        };
2214        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2215    };
2216
2217    let local_var_req = local_var_req_builder.build()?;
2218    let local_var_resp = local_var_client.execute(local_var_req).await?;
2219
2220    let local_var_status = local_var_resp.status();
2221    let local_var_content = local_var_resp.text().await?;
2222
2223    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2224        serde_json::from_str(&local_var_content).map_err(Error::from)
2225    } else {
2226        let local_var_entity: Option<VirtualizationClusterGroupsListError> =
2227            serde_json::from_str(&local_var_content).ok();
2228        let local_var_error = ResponseContent {
2229            status: local_var_status,
2230            content: local_var_content,
2231            entity: local_var_entity,
2232        };
2233        Err(Error::ResponseError(local_var_error))
2234    }
2235}
2236
2237/// Patch a cluster group object.
2238pub async fn virtualization_cluster_groups_partial_update(
2239    configuration: &configuration::Configuration,
2240    id: i32,
2241    patched_cluster_group_request: Option<crate::models::PatchedClusterGroupRequest>,
2242) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsPartialUpdateError>> {
2243    let local_var_configuration = configuration;
2244
2245    let local_var_client = &local_var_configuration.client;
2246
2247    let local_var_uri_str = format!(
2248        "{}/api/virtualization/cluster-groups/{id}/",
2249        local_var_configuration.base_path,
2250        id = id
2251    );
2252    let mut local_var_req_builder =
2253        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2254
2255    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2256        local_var_req_builder =
2257            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2258    }
2259    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2260        let local_var_key = local_var_apikey.key.clone();
2261        let local_var_value = match local_var_apikey.prefix {
2262            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2263            None => local_var_key,
2264        };
2265        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2266    };
2267    local_var_req_builder = local_var_req_builder.json(&patched_cluster_group_request);
2268
2269    let local_var_req = local_var_req_builder.build()?;
2270    let local_var_resp = local_var_client.execute(local_var_req).await?;
2271
2272    let local_var_status = local_var_resp.status();
2273    let local_var_content = local_var_resp.text().await?;
2274
2275    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2276        serde_json::from_str(&local_var_content).map_err(Error::from)
2277    } else {
2278        let local_var_entity: Option<VirtualizationClusterGroupsPartialUpdateError> =
2279            serde_json::from_str(&local_var_content).ok();
2280        let local_var_error = ResponseContent {
2281            status: local_var_status,
2282            content: local_var_content,
2283            entity: local_var_entity,
2284        };
2285        Err(Error::ResponseError(local_var_error))
2286    }
2287}
2288
2289/// Get a cluster group object.
2290pub async fn virtualization_cluster_groups_retrieve(
2291    configuration: &configuration::Configuration,
2292    id: i32,
2293) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsRetrieveError>> {
2294    let local_var_configuration = configuration;
2295
2296    let local_var_client = &local_var_configuration.client;
2297
2298    let local_var_uri_str = format!(
2299        "{}/api/virtualization/cluster-groups/{id}/",
2300        local_var_configuration.base_path,
2301        id = id
2302    );
2303    let mut local_var_req_builder =
2304        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2305
2306    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2307        local_var_req_builder =
2308            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2309    }
2310    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2311        let local_var_key = local_var_apikey.key.clone();
2312        let local_var_value = match local_var_apikey.prefix {
2313            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2314            None => local_var_key,
2315        };
2316        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2317    };
2318
2319    let local_var_req = local_var_req_builder.build()?;
2320    let local_var_resp = local_var_client.execute(local_var_req).await?;
2321
2322    let local_var_status = local_var_resp.status();
2323    let local_var_content = local_var_resp.text().await?;
2324
2325    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2326        serde_json::from_str(&local_var_content).map_err(Error::from)
2327    } else {
2328        let local_var_entity: Option<VirtualizationClusterGroupsRetrieveError> =
2329            serde_json::from_str(&local_var_content).ok();
2330        let local_var_error = ResponseContent {
2331            status: local_var_status,
2332            content: local_var_content,
2333            entity: local_var_entity,
2334        };
2335        Err(Error::ResponseError(local_var_error))
2336    }
2337}
2338
2339/// Put a cluster group object.
2340pub async fn virtualization_cluster_groups_update(
2341    configuration: &configuration::Configuration,
2342    id: i32,
2343    cluster_group_request: crate::models::ClusterGroupRequest,
2344) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsUpdateError>> {
2345    let local_var_configuration = configuration;
2346
2347    let local_var_client = &local_var_configuration.client;
2348
2349    let local_var_uri_str = format!(
2350        "{}/api/virtualization/cluster-groups/{id}/",
2351        local_var_configuration.base_path,
2352        id = id
2353    );
2354    let mut local_var_req_builder =
2355        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2356
2357    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2358        local_var_req_builder =
2359            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2360    }
2361    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2362        let local_var_key = local_var_apikey.key.clone();
2363        let local_var_value = match local_var_apikey.prefix {
2364            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2365            None => local_var_key,
2366        };
2367        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2368    };
2369    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
2370
2371    let local_var_req = local_var_req_builder.build()?;
2372    let local_var_resp = local_var_client.execute(local_var_req).await?;
2373
2374    let local_var_status = local_var_resp.status();
2375    let local_var_content = local_var_resp.text().await?;
2376
2377    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2378        serde_json::from_str(&local_var_content).map_err(Error::from)
2379    } else {
2380        let local_var_entity: Option<VirtualizationClusterGroupsUpdateError> =
2381            serde_json::from_str(&local_var_content).ok();
2382        let local_var_error = ResponseContent {
2383            status: local_var_status,
2384            content: local_var_content,
2385            entity: local_var_entity,
2386        };
2387        Err(Error::ResponseError(local_var_error))
2388    }
2389}
2390
2391/// Delete a list of cluster type objects.
2392pub async fn virtualization_cluster_types_bulk_destroy(
2393    configuration: &configuration::Configuration,
2394    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2395) -> Result<(), Error<VirtualizationClusterTypesBulkDestroyError>> {
2396    let local_var_configuration = configuration;
2397
2398    let local_var_client = &local_var_configuration.client;
2399
2400    let local_var_uri_str = format!(
2401        "{}/api/virtualization/cluster-types/",
2402        local_var_configuration.base_path
2403    );
2404    let mut local_var_req_builder =
2405        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2406
2407    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2408        local_var_req_builder =
2409            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2410    }
2411    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2412        let local_var_key = local_var_apikey.key.clone();
2413        let local_var_value = match local_var_apikey.prefix {
2414            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2415            None => local_var_key,
2416        };
2417        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2418    };
2419    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2420
2421    let local_var_req = local_var_req_builder.build()?;
2422    let local_var_resp = local_var_client.execute(local_var_req).await?;
2423
2424    let local_var_status = local_var_resp.status();
2425    let local_var_content = local_var_resp.text().await?;
2426
2427    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2428        Ok(())
2429    } else {
2430        let local_var_entity: Option<VirtualizationClusterTypesBulkDestroyError> =
2431            serde_json::from_str(&local_var_content).ok();
2432        let local_var_error = ResponseContent {
2433            status: local_var_status,
2434            content: local_var_content,
2435            entity: local_var_entity,
2436        };
2437        Err(Error::ResponseError(local_var_error))
2438    }
2439}
2440
2441/// Patch a list of cluster type objects.
2442pub async fn virtualization_cluster_types_bulk_partial_update(
2443    configuration: &configuration::Configuration,
2444    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2445) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkPartialUpdateError>>
2446{
2447    let local_var_configuration = configuration;
2448
2449    let local_var_client = &local_var_configuration.client;
2450
2451    let local_var_uri_str = format!(
2452        "{}/api/virtualization/cluster-types/",
2453        local_var_configuration.base_path
2454    );
2455    let mut local_var_req_builder =
2456        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2457
2458    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2459        local_var_req_builder =
2460            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2461    }
2462    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2463        let local_var_key = local_var_apikey.key.clone();
2464        let local_var_value = match local_var_apikey.prefix {
2465            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2466            None => local_var_key,
2467        };
2468        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2469    };
2470    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2471
2472    let local_var_req = local_var_req_builder.build()?;
2473    let local_var_resp = local_var_client.execute(local_var_req).await?;
2474
2475    let local_var_status = local_var_resp.status();
2476    let local_var_content = local_var_resp.text().await?;
2477
2478    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2479        serde_json::from_str(&local_var_content).map_err(Error::from)
2480    } else {
2481        let local_var_entity: Option<VirtualizationClusterTypesBulkPartialUpdateError> =
2482            serde_json::from_str(&local_var_content).ok();
2483        let local_var_error = ResponseContent {
2484            status: local_var_status,
2485            content: local_var_content,
2486            entity: local_var_entity,
2487        };
2488        Err(Error::ResponseError(local_var_error))
2489    }
2490}
2491
2492/// Put a list of cluster type objects.
2493pub async fn virtualization_cluster_types_bulk_update(
2494    configuration: &configuration::Configuration,
2495    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2496) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkUpdateError>> {
2497    let local_var_configuration = configuration;
2498
2499    let local_var_client = &local_var_configuration.client;
2500
2501    let local_var_uri_str = format!(
2502        "{}/api/virtualization/cluster-types/",
2503        local_var_configuration.base_path
2504    );
2505    let mut local_var_req_builder =
2506        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2507
2508    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2509        local_var_req_builder =
2510            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2511    }
2512    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2513        let local_var_key = local_var_apikey.key.clone();
2514        let local_var_value = match local_var_apikey.prefix {
2515            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2516            None => local_var_key,
2517        };
2518        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2519    };
2520    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2521
2522    let local_var_req = local_var_req_builder.build()?;
2523    let local_var_resp = local_var_client.execute(local_var_req).await?;
2524
2525    let local_var_status = local_var_resp.status();
2526    let local_var_content = local_var_resp.text().await?;
2527
2528    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2529        serde_json::from_str(&local_var_content).map_err(Error::from)
2530    } else {
2531        let local_var_entity: Option<VirtualizationClusterTypesBulkUpdateError> =
2532            serde_json::from_str(&local_var_content).ok();
2533        let local_var_error = ResponseContent {
2534            status: local_var_status,
2535            content: local_var_content,
2536            entity: local_var_entity,
2537        };
2538        Err(Error::ResponseError(local_var_error))
2539    }
2540}
2541
2542/// Post a list of cluster type objects.
2543pub async fn virtualization_cluster_types_create(
2544    configuration: &configuration::Configuration,
2545    virtualization_cluster_types_create_request: crate::models::VirtualizationClusterTypesCreateRequest,
2546) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesCreateError>> {
2547    let local_var_configuration = configuration;
2548
2549    let local_var_client = &local_var_configuration.client;
2550
2551    let local_var_uri_str = format!(
2552        "{}/api/virtualization/cluster-types/",
2553        local_var_configuration.base_path
2554    );
2555    let mut local_var_req_builder =
2556        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2557
2558    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2559        local_var_req_builder =
2560            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2561    }
2562    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2563        let local_var_key = local_var_apikey.key.clone();
2564        let local_var_value = match local_var_apikey.prefix {
2565            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2566            None => local_var_key,
2567        };
2568        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2569    };
2570    local_var_req_builder =
2571        local_var_req_builder.json(&virtualization_cluster_types_create_request);
2572
2573    let local_var_req = local_var_req_builder.build()?;
2574    let local_var_resp = local_var_client.execute(local_var_req).await?;
2575
2576    let local_var_status = local_var_resp.status();
2577    let local_var_content = local_var_resp.text().await?;
2578
2579    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2580        serde_json::from_str(&local_var_content).map_err(Error::from)
2581    } else {
2582        let local_var_entity: Option<VirtualizationClusterTypesCreateError> =
2583            serde_json::from_str(&local_var_content).ok();
2584        let local_var_error = ResponseContent {
2585            status: local_var_status,
2586            content: local_var_content,
2587            entity: local_var_entity,
2588        };
2589        Err(Error::ResponseError(local_var_error))
2590    }
2591}
2592
2593/// Delete a cluster type object.
2594pub async fn virtualization_cluster_types_destroy(
2595    configuration: &configuration::Configuration,
2596    id: i32,
2597) -> Result<(), Error<VirtualizationClusterTypesDestroyError>> {
2598    let local_var_configuration = configuration;
2599
2600    let local_var_client = &local_var_configuration.client;
2601
2602    let local_var_uri_str = format!(
2603        "{}/api/virtualization/cluster-types/{id}/",
2604        local_var_configuration.base_path,
2605        id = id
2606    );
2607    let mut local_var_req_builder =
2608        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2609
2610    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2611        local_var_req_builder =
2612            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2613    }
2614    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2615        let local_var_key = local_var_apikey.key.clone();
2616        let local_var_value = match local_var_apikey.prefix {
2617            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2618            None => local_var_key,
2619        };
2620        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2621    };
2622
2623    let local_var_req = local_var_req_builder.build()?;
2624    let local_var_resp = local_var_client.execute(local_var_req).await?;
2625
2626    let local_var_status = local_var_resp.status();
2627    let local_var_content = local_var_resp.text().await?;
2628
2629    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2630        Ok(())
2631    } else {
2632        let local_var_entity: Option<VirtualizationClusterTypesDestroyError> =
2633            serde_json::from_str(&local_var_content).ok();
2634        let local_var_error = ResponseContent {
2635            status: local_var_status,
2636            content: local_var_content,
2637            entity: local_var_entity,
2638        };
2639        Err(Error::ResponseError(local_var_error))
2640    }
2641}
2642
2643/// Get a list of cluster type objects.
2644pub async fn virtualization_cluster_types_list(
2645    configuration: &configuration::Configuration,
2646    created: Option<Vec<String>>,
2647    created__empty: Option<Vec<String>>,
2648    created__gt: Option<Vec<String>>,
2649    created__gte: Option<Vec<String>>,
2650    created__lt: Option<Vec<String>>,
2651    created__lte: Option<Vec<String>>,
2652    created__n: Option<Vec<String>>,
2653    created_by_request: Option<&str>,
2654    description: Option<Vec<String>>,
2655    description__empty: Option<bool>,
2656    description__ic: Option<Vec<String>>,
2657    description__ie: Option<Vec<String>>,
2658    description__iew: Option<Vec<String>>,
2659    description__iregex: Option<Vec<String>>,
2660    description__isw: Option<Vec<String>>,
2661    description__n: Option<Vec<String>>,
2662    description__nic: Option<Vec<String>>,
2663    description__nie: Option<Vec<String>>,
2664    description__niew: Option<Vec<String>>,
2665    description__nisw: Option<Vec<String>>,
2666    description__regex: Option<Vec<String>>,
2667    id: Option<Vec<i32>>,
2668    id__empty: Option<bool>,
2669    id__gt: Option<Vec<i32>>,
2670    id__gte: Option<Vec<i32>>,
2671    id__lt: Option<Vec<i32>>,
2672    id__lte: Option<Vec<i32>>,
2673    id__n: Option<Vec<i32>>,
2674    last_updated: Option<Vec<String>>,
2675    last_updated__empty: Option<Vec<String>>,
2676    last_updated__gt: Option<Vec<String>>,
2677    last_updated__gte: Option<Vec<String>>,
2678    last_updated__lt: Option<Vec<String>>,
2679    last_updated__lte: Option<Vec<String>>,
2680    last_updated__n: Option<Vec<String>>,
2681    limit: Option<i32>,
2682    modified_by_request: Option<&str>,
2683    name: Option<Vec<String>>,
2684    name__empty: Option<bool>,
2685    name__ic: Option<Vec<String>>,
2686    name__ie: Option<Vec<String>>,
2687    name__iew: Option<Vec<String>>,
2688    name__iregex: Option<Vec<String>>,
2689    name__isw: Option<Vec<String>>,
2690    name__n: Option<Vec<String>>,
2691    name__nic: Option<Vec<String>>,
2692    name__nie: Option<Vec<String>>,
2693    name__niew: Option<Vec<String>>,
2694    name__nisw: Option<Vec<String>>,
2695    name__regex: Option<Vec<String>>,
2696    offset: Option<i32>,
2697    ordering: Option<&str>,
2698    owner: Option<Vec<String>>,
2699    owner__n: Option<Vec<String>>,
2700    owner_group: Option<Vec<String>>,
2701    owner_group__n: Option<Vec<String>>,
2702    owner_group_id: Option<Vec<i32>>,
2703    owner_group_id__n: Option<Vec<i32>>,
2704    owner_id: Option<Vec<i32>>,
2705    owner_id__n: Option<Vec<i32>>,
2706    q: Option<&str>,
2707    slug: Option<Vec<String>>,
2708    slug__empty: Option<bool>,
2709    slug__ic: Option<Vec<String>>,
2710    slug__ie: Option<Vec<String>>,
2711    slug__iew: Option<Vec<String>>,
2712    slug__iregex: Option<Vec<String>>,
2713    slug__isw: Option<Vec<String>>,
2714    slug__n: Option<Vec<String>>,
2715    slug__nic: Option<Vec<String>>,
2716    slug__nie: Option<Vec<String>>,
2717    slug__niew: Option<Vec<String>>,
2718    slug__nisw: Option<Vec<String>>,
2719    slug__regex: Option<Vec<String>>,
2720    tag: Option<Vec<String>>,
2721    tag__n: Option<Vec<String>>,
2722    tag_id: Option<Vec<i32>>,
2723    tag_id__n: Option<Vec<i32>>,
2724    updated_by_request: Option<&str>,
2725) -> Result<crate::models::PaginatedClusterTypeList, Error<VirtualizationClusterTypesListError>> {
2726    let local_var_configuration = configuration;
2727
2728    let local_var_client = &local_var_configuration.client;
2729
2730    let local_var_uri_str = format!(
2731        "{}/api/virtualization/cluster-types/",
2732        local_var_configuration.base_path
2733    );
2734    let mut local_var_req_builder =
2735        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2736
2737    if let Some(ref local_var_str) = created {
2738        local_var_req_builder = match "multi" {
2739            "multi" => local_var_req_builder.query(
2740                &local_var_str
2741                    .into_iter()
2742                    .map(|p| ("created".to_owned(), p.to_string()))
2743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2744            ),
2745            _ => local_var_req_builder.query(&[(
2746                "created",
2747                &local_var_str
2748                    .into_iter()
2749                    .map(|p| p.to_string())
2750                    .collect::<Vec<String>>()
2751                    .join(",")
2752                    .to_string(),
2753            )]),
2754        };
2755    }
2756    if let Some(ref local_var_str) = created__empty {
2757        local_var_req_builder = match "multi" {
2758            "multi" => local_var_req_builder.query(
2759                &local_var_str
2760                    .into_iter()
2761                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2763            ),
2764            _ => local_var_req_builder.query(&[(
2765                "created__empty",
2766                &local_var_str
2767                    .into_iter()
2768                    .map(|p| p.to_string())
2769                    .collect::<Vec<String>>()
2770                    .join(",")
2771                    .to_string(),
2772            )]),
2773        };
2774    }
2775    if let Some(ref local_var_str) = created__gt {
2776        local_var_req_builder = match "multi" {
2777            "multi" => local_var_req_builder.query(
2778                &local_var_str
2779                    .into_iter()
2780                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2782            ),
2783            _ => local_var_req_builder.query(&[(
2784                "created__gt",
2785                &local_var_str
2786                    .into_iter()
2787                    .map(|p| p.to_string())
2788                    .collect::<Vec<String>>()
2789                    .join(",")
2790                    .to_string(),
2791            )]),
2792        };
2793    }
2794    if let Some(ref local_var_str) = created__gte {
2795        local_var_req_builder = match "multi" {
2796            "multi" => local_var_req_builder.query(
2797                &local_var_str
2798                    .into_iter()
2799                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2801            ),
2802            _ => local_var_req_builder.query(&[(
2803                "created__gte",
2804                &local_var_str
2805                    .into_iter()
2806                    .map(|p| p.to_string())
2807                    .collect::<Vec<String>>()
2808                    .join(",")
2809                    .to_string(),
2810            )]),
2811        };
2812    }
2813    if let Some(ref local_var_str) = created__lt {
2814        local_var_req_builder = match "multi" {
2815            "multi" => local_var_req_builder.query(
2816                &local_var_str
2817                    .into_iter()
2818                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2820            ),
2821            _ => local_var_req_builder.query(&[(
2822                "created__lt",
2823                &local_var_str
2824                    .into_iter()
2825                    .map(|p| p.to_string())
2826                    .collect::<Vec<String>>()
2827                    .join(",")
2828                    .to_string(),
2829            )]),
2830        };
2831    }
2832    if let Some(ref local_var_str) = created__lte {
2833        local_var_req_builder = match "multi" {
2834            "multi" => local_var_req_builder.query(
2835                &local_var_str
2836                    .into_iter()
2837                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2839            ),
2840            _ => local_var_req_builder.query(&[(
2841                "created__lte",
2842                &local_var_str
2843                    .into_iter()
2844                    .map(|p| p.to_string())
2845                    .collect::<Vec<String>>()
2846                    .join(",")
2847                    .to_string(),
2848            )]),
2849        };
2850    }
2851    if let Some(ref local_var_str) = created__n {
2852        local_var_req_builder = match "multi" {
2853            "multi" => local_var_req_builder.query(
2854                &local_var_str
2855                    .into_iter()
2856                    .map(|p| ("created__n".to_owned(), p.to_string()))
2857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2858            ),
2859            _ => local_var_req_builder.query(&[(
2860                "created__n",
2861                &local_var_str
2862                    .into_iter()
2863                    .map(|p| p.to_string())
2864                    .collect::<Vec<String>>()
2865                    .join(",")
2866                    .to_string(),
2867            )]),
2868        };
2869    }
2870    if let Some(ref local_var_str) = created_by_request {
2871        local_var_req_builder =
2872            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2873    }
2874    if let Some(ref local_var_str) = description {
2875        local_var_req_builder = match "multi" {
2876            "multi" => local_var_req_builder.query(
2877                &local_var_str
2878                    .into_iter()
2879                    .map(|p| ("description".to_owned(), p.to_string()))
2880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2881            ),
2882            _ => local_var_req_builder.query(&[(
2883                "description",
2884                &local_var_str
2885                    .into_iter()
2886                    .map(|p| p.to_string())
2887                    .collect::<Vec<String>>()
2888                    .join(",")
2889                    .to_string(),
2890            )]),
2891        };
2892    }
2893    if let Some(ref local_var_str) = description__empty {
2894        local_var_req_builder =
2895            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2896    }
2897    if let Some(ref local_var_str) = description__ic {
2898        local_var_req_builder = match "multi" {
2899            "multi" => local_var_req_builder.query(
2900                &local_var_str
2901                    .into_iter()
2902                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2904            ),
2905            _ => local_var_req_builder.query(&[(
2906                "description__ic",
2907                &local_var_str
2908                    .into_iter()
2909                    .map(|p| p.to_string())
2910                    .collect::<Vec<String>>()
2911                    .join(",")
2912                    .to_string(),
2913            )]),
2914        };
2915    }
2916    if let Some(ref local_var_str) = description__ie {
2917        local_var_req_builder = match "multi" {
2918            "multi" => local_var_req_builder.query(
2919                &local_var_str
2920                    .into_iter()
2921                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2923            ),
2924            _ => local_var_req_builder.query(&[(
2925                "description__ie",
2926                &local_var_str
2927                    .into_iter()
2928                    .map(|p| p.to_string())
2929                    .collect::<Vec<String>>()
2930                    .join(",")
2931                    .to_string(),
2932            )]),
2933        };
2934    }
2935    if let Some(ref local_var_str) = description__iew {
2936        local_var_req_builder = match "multi" {
2937            "multi" => local_var_req_builder.query(
2938                &local_var_str
2939                    .into_iter()
2940                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2942            ),
2943            _ => local_var_req_builder.query(&[(
2944                "description__iew",
2945                &local_var_str
2946                    .into_iter()
2947                    .map(|p| p.to_string())
2948                    .collect::<Vec<String>>()
2949                    .join(",")
2950                    .to_string(),
2951            )]),
2952        };
2953    }
2954    if let Some(ref local_var_str) = description__iregex {
2955        local_var_req_builder = match "multi" {
2956            "multi" => local_var_req_builder.query(
2957                &local_var_str
2958                    .into_iter()
2959                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2961            ),
2962            _ => local_var_req_builder.query(&[(
2963                "description__iregex",
2964                &local_var_str
2965                    .into_iter()
2966                    .map(|p| p.to_string())
2967                    .collect::<Vec<String>>()
2968                    .join(",")
2969                    .to_string(),
2970            )]),
2971        };
2972    }
2973    if let Some(ref local_var_str) = description__isw {
2974        local_var_req_builder = match "multi" {
2975            "multi" => local_var_req_builder.query(
2976                &local_var_str
2977                    .into_iter()
2978                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2980            ),
2981            _ => local_var_req_builder.query(&[(
2982                "description__isw",
2983                &local_var_str
2984                    .into_iter()
2985                    .map(|p| p.to_string())
2986                    .collect::<Vec<String>>()
2987                    .join(",")
2988                    .to_string(),
2989            )]),
2990        };
2991    }
2992    if let Some(ref local_var_str) = description__n {
2993        local_var_req_builder = match "multi" {
2994            "multi" => local_var_req_builder.query(
2995                &local_var_str
2996                    .into_iter()
2997                    .map(|p| ("description__n".to_owned(), p.to_string()))
2998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2999            ),
3000            _ => local_var_req_builder.query(&[(
3001                "description__n",
3002                &local_var_str
3003                    .into_iter()
3004                    .map(|p| p.to_string())
3005                    .collect::<Vec<String>>()
3006                    .join(",")
3007                    .to_string(),
3008            )]),
3009        };
3010    }
3011    if let Some(ref local_var_str) = description__nic {
3012        local_var_req_builder = match "multi" {
3013            "multi" => local_var_req_builder.query(
3014                &local_var_str
3015                    .into_iter()
3016                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3018            ),
3019            _ => local_var_req_builder.query(&[(
3020                "description__nic",
3021                &local_var_str
3022                    .into_iter()
3023                    .map(|p| p.to_string())
3024                    .collect::<Vec<String>>()
3025                    .join(",")
3026                    .to_string(),
3027            )]),
3028        };
3029    }
3030    if let Some(ref local_var_str) = description__nie {
3031        local_var_req_builder = match "multi" {
3032            "multi" => local_var_req_builder.query(
3033                &local_var_str
3034                    .into_iter()
3035                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3037            ),
3038            _ => local_var_req_builder.query(&[(
3039                "description__nie",
3040                &local_var_str
3041                    .into_iter()
3042                    .map(|p| p.to_string())
3043                    .collect::<Vec<String>>()
3044                    .join(",")
3045                    .to_string(),
3046            )]),
3047        };
3048    }
3049    if let Some(ref local_var_str) = description__niew {
3050        local_var_req_builder = match "multi" {
3051            "multi" => local_var_req_builder.query(
3052                &local_var_str
3053                    .into_iter()
3054                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3056            ),
3057            _ => local_var_req_builder.query(&[(
3058                "description__niew",
3059                &local_var_str
3060                    .into_iter()
3061                    .map(|p| p.to_string())
3062                    .collect::<Vec<String>>()
3063                    .join(",")
3064                    .to_string(),
3065            )]),
3066        };
3067    }
3068    if let Some(ref local_var_str) = description__nisw {
3069        local_var_req_builder = match "multi" {
3070            "multi" => local_var_req_builder.query(
3071                &local_var_str
3072                    .into_iter()
3073                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3075            ),
3076            _ => local_var_req_builder.query(&[(
3077                "description__nisw",
3078                &local_var_str
3079                    .into_iter()
3080                    .map(|p| p.to_string())
3081                    .collect::<Vec<String>>()
3082                    .join(",")
3083                    .to_string(),
3084            )]),
3085        };
3086    }
3087    if let Some(ref local_var_str) = description__regex {
3088        local_var_req_builder = match "multi" {
3089            "multi" => local_var_req_builder.query(
3090                &local_var_str
3091                    .into_iter()
3092                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3094            ),
3095            _ => local_var_req_builder.query(&[(
3096                "description__regex",
3097                &local_var_str
3098                    .into_iter()
3099                    .map(|p| p.to_string())
3100                    .collect::<Vec<String>>()
3101                    .join(",")
3102                    .to_string(),
3103            )]),
3104        };
3105    }
3106    if let Some(ref local_var_str) = id {
3107        local_var_req_builder = match "multi" {
3108            "multi" => local_var_req_builder.query(
3109                &local_var_str
3110                    .into_iter()
3111                    .map(|p| ("id".to_owned(), p.to_string()))
3112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3113            ),
3114            _ => local_var_req_builder.query(&[(
3115                "id",
3116                &local_var_str
3117                    .into_iter()
3118                    .map(|p| p.to_string())
3119                    .collect::<Vec<String>>()
3120                    .join(",")
3121                    .to_string(),
3122            )]),
3123        };
3124    }
3125    if let Some(ref local_var_str) = id__empty {
3126        local_var_req_builder =
3127            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
3128    }
3129    if let Some(ref local_var_str) = id__gt {
3130        local_var_req_builder = match "multi" {
3131            "multi" => local_var_req_builder.query(
3132                &local_var_str
3133                    .into_iter()
3134                    .map(|p| ("id__gt".to_owned(), p.to_string()))
3135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3136            ),
3137            _ => local_var_req_builder.query(&[(
3138                "id__gt",
3139                &local_var_str
3140                    .into_iter()
3141                    .map(|p| p.to_string())
3142                    .collect::<Vec<String>>()
3143                    .join(",")
3144                    .to_string(),
3145            )]),
3146        };
3147    }
3148    if let Some(ref local_var_str) = id__gte {
3149        local_var_req_builder = match "multi" {
3150            "multi" => local_var_req_builder.query(
3151                &local_var_str
3152                    .into_iter()
3153                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3155            ),
3156            _ => local_var_req_builder.query(&[(
3157                "id__gte",
3158                &local_var_str
3159                    .into_iter()
3160                    .map(|p| p.to_string())
3161                    .collect::<Vec<String>>()
3162                    .join(",")
3163                    .to_string(),
3164            )]),
3165        };
3166    }
3167    if let Some(ref local_var_str) = id__lt {
3168        local_var_req_builder = match "multi" {
3169            "multi" => local_var_req_builder.query(
3170                &local_var_str
3171                    .into_iter()
3172                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3174            ),
3175            _ => local_var_req_builder.query(&[(
3176                "id__lt",
3177                &local_var_str
3178                    .into_iter()
3179                    .map(|p| p.to_string())
3180                    .collect::<Vec<String>>()
3181                    .join(",")
3182                    .to_string(),
3183            )]),
3184        };
3185    }
3186    if let Some(ref local_var_str) = id__lte {
3187        local_var_req_builder = match "multi" {
3188            "multi" => local_var_req_builder.query(
3189                &local_var_str
3190                    .into_iter()
3191                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3193            ),
3194            _ => local_var_req_builder.query(&[(
3195                "id__lte",
3196                &local_var_str
3197                    .into_iter()
3198                    .map(|p| p.to_string())
3199                    .collect::<Vec<String>>()
3200                    .join(",")
3201                    .to_string(),
3202            )]),
3203        };
3204    }
3205    if let Some(ref local_var_str) = id__n {
3206        local_var_req_builder = match "multi" {
3207            "multi" => local_var_req_builder.query(
3208                &local_var_str
3209                    .into_iter()
3210                    .map(|p| ("id__n".to_owned(), p.to_string()))
3211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3212            ),
3213            _ => local_var_req_builder.query(&[(
3214                "id__n",
3215                &local_var_str
3216                    .into_iter()
3217                    .map(|p| p.to_string())
3218                    .collect::<Vec<String>>()
3219                    .join(",")
3220                    .to_string(),
3221            )]),
3222        };
3223    }
3224    if let Some(ref local_var_str) = last_updated {
3225        local_var_req_builder = match "multi" {
3226            "multi" => local_var_req_builder.query(
3227                &local_var_str
3228                    .into_iter()
3229                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3231            ),
3232            _ => local_var_req_builder.query(&[(
3233                "last_updated",
3234                &local_var_str
3235                    .into_iter()
3236                    .map(|p| p.to_string())
3237                    .collect::<Vec<String>>()
3238                    .join(",")
3239                    .to_string(),
3240            )]),
3241        };
3242    }
3243    if let Some(ref local_var_str) = last_updated__empty {
3244        local_var_req_builder = match "multi" {
3245            "multi" => local_var_req_builder.query(
3246                &local_var_str
3247                    .into_iter()
3248                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3250            ),
3251            _ => local_var_req_builder.query(&[(
3252                "last_updated__empty",
3253                &local_var_str
3254                    .into_iter()
3255                    .map(|p| p.to_string())
3256                    .collect::<Vec<String>>()
3257                    .join(",")
3258                    .to_string(),
3259            )]),
3260        };
3261    }
3262    if let Some(ref local_var_str) = last_updated__gt {
3263        local_var_req_builder = match "multi" {
3264            "multi" => local_var_req_builder.query(
3265                &local_var_str
3266                    .into_iter()
3267                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3269            ),
3270            _ => local_var_req_builder.query(&[(
3271                "last_updated__gt",
3272                &local_var_str
3273                    .into_iter()
3274                    .map(|p| p.to_string())
3275                    .collect::<Vec<String>>()
3276                    .join(",")
3277                    .to_string(),
3278            )]),
3279        };
3280    }
3281    if let Some(ref local_var_str) = last_updated__gte {
3282        local_var_req_builder = match "multi" {
3283            "multi" => local_var_req_builder.query(
3284                &local_var_str
3285                    .into_iter()
3286                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3288            ),
3289            _ => local_var_req_builder.query(&[(
3290                "last_updated__gte",
3291                &local_var_str
3292                    .into_iter()
3293                    .map(|p| p.to_string())
3294                    .collect::<Vec<String>>()
3295                    .join(",")
3296                    .to_string(),
3297            )]),
3298        };
3299    }
3300    if let Some(ref local_var_str) = last_updated__lt {
3301        local_var_req_builder = match "multi" {
3302            "multi" => local_var_req_builder.query(
3303                &local_var_str
3304                    .into_iter()
3305                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3307            ),
3308            _ => local_var_req_builder.query(&[(
3309                "last_updated__lt",
3310                &local_var_str
3311                    .into_iter()
3312                    .map(|p| p.to_string())
3313                    .collect::<Vec<String>>()
3314                    .join(",")
3315                    .to_string(),
3316            )]),
3317        };
3318    }
3319    if let Some(ref local_var_str) = last_updated__lte {
3320        local_var_req_builder = match "multi" {
3321            "multi" => local_var_req_builder.query(
3322                &local_var_str
3323                    .into_iter()
3324                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3326            ),
3327            _ => local_var_req_builder.query(&[(
3328                "last_updated__lte",
3329                &local_var_str
3330                    .into_iter()
3331                    .map(|p| p.to_string())
3332                    .collect::<Vec<String>>()
3333                    .join(",")
3334                    .to_string(),
3335            )]),
3336        };
3337    }
3338    if let Some(ref local_var_str) = last_updated__n {
3339        local_var_req_builder = match "multi" {
3340            "multi" => local_var_req_builder.query(
3341                &local_var_str
3342                    .into_iter()
3343                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3345            ),
3346            _ => local_var_req_builder.query(&[(
3347                "last_updated__n",
3348                &local_var_str
3349                    .into_iter()
3350                    .map(|p| p.to_string())
3351                    .collect::<Vec<String>>()
3352                    .join(",")
3353                    .to_string(),
3354            )]),
3355        };
3356    }
3357    if let Some(ref local_var_str) = limit {
3358        local_var_req_builder =
3359            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3360    }
3361    if let Some(ref local_var_str) = modified_by_request {
3362        local_var_req_builder =
3363            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3364    }
3365    if let Some(ref local_var_str) = name {
3366        local_var_req_builder = match "multi" {
3367            "multi" => local_var_req_builder.query(
3368                &local_var_str
3369                    .into_iter()
3370                    .map(|p| ("name".to_owned(), p.to_string()))
3371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3372            ),
3373            _ => local_var_req_builder.query(&[(
3374                "name",
3375                &local_var_str
3376                    .into_iter()
3377                    .map(|p| p.to_string())
3378                    .collect::<Vec<String>>()
3379                    .join(",")
3380                    .to_string(),
3381            )]),
3382        };
3383    }
3384    if let Some(ref local_var_str) = name__empty {
3385        local_var_req_builder =
3386            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3387    }
3388    if let Some(ref local_var_str) = name__ic {
3389        local_var_req_builder = match "multi" {
3390            "multi" => local_var_req_builder.query(
3391                &local_var_str
3392                    .into_iter()
3393                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3395            ),
3396            _ => local_var_req_builder.query(&[(
3397                "name__ic",
3398                &local_var_str
3399                    .into_iter()
3400                    .map(|p| p.to_string())
3401                    .collect::<Vec<String>>()
3402                    .join(",")
3403                    .to_string(),
3404            )]),
3405        };
3406    }
3407    if let Some(ref local_var_str) = name__ie {
3408        local_var_req_builder = match "multi" {
3409            "multi" => local_var_req_builder.query(
3410                &local_var_str
3411                    .into_iter()
3412                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3414            ),
3415            _ => local_var_req_builder.query(&[(
3416                "name__ie",
3417                &local_var_str
3418                    .into_iter()
3419                    .map(|p| p.to_string())
3420                    .collect::<Vec<String>>()
3421                    .join(",")
3422                    .to_string(),
3423            )]),
3424        };
3425    }
3426    if let Some(ref local_var_str) = name__iew {
3427        local_var_req_builder = match "multi" {
3428            "multi" => local_var_req_builder.query(
3429                &local_var_str
3430                    .into_iter()
3431                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3433            ),
3434            _ => local_var_req_builder.query(&[(
3435                "name__iew",
3436                &local_var_str
3437                    .into_iter()
3438                    .map(|p| p.to_string())
3439                    .collect::<Vec<String>>()
3440                    .join(",")
3441                    .to_string(),
3442            )]),
3443        };
3444    }
3445    if let Some(ref local_var_str) = name__iregex {
3446        local_var_req_builder = match "multi" {
3447            "multi" => local_var_req_builder.query(
3448                &local_var_str
3449                    .into_iter()
3450                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3452            ),
3453            _ => local_var_req_builder.query(&[(
3454                "name__iregex",
3455                &local_var_str
3456                    .into_iter()
3457                    .map(|p| p.to_string())
3458                    .collect::<Vec<String>>()
3459                    .join(",")
3460                    .to_string(),
3461            )]),
3462        };
3463    }
3464    if let Some(ref local_var_str) = name__isw {
3465        local_var_req_builder = match "multi" {
3466            "multi" => local_var_req_builder.query(
3467                &local_var_str
3468                    .into_iter()
3469                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3471            ),
3472            _ => local_var_req_builder.query(&[(
3473                "name__isw",
3474                &local_var_str
3475                    .into_iter()
3476                    .map(|p| p.to_string())
3477                    .collect::<Vec<String>>()
3478                    .join(",")
3479                    .to_string(),
3480            )]),
3481        };
3482    }
3483    if let Some(ref local_var_str) = name__n {
3484        local_var_req_builder = match "multi" {
3485            "multi" => local_var_req_builder.query(
3486                &local_var_str
3487                    .into_iter()
3488                    .map(|p| ("name__n".to_owned(), p.to_string()))
3489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3490            ),
3491            _ => local_var_req_builder.query(&[(
3492                "name__n",
3493                &local_var_str
3494                    .into_iter()
3495                    .map(|p| p.to_string())
3496                    .collect::<Vec<String>>()
3497                    .join(",")
3498                    .to_string(),
3499            )]),
3500        };
3501    }
3502    if let Some(ref local_var_str) = name__nic {
3503        local_var_req_builder = match "multi" {
3504            "multi" => local_var_req_builder.query(
3505                &local_var_str
3506                    .into_iter()
3507                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3509            ),
3510            _ => local_var_req_builder.query(&[(
3511                "name__nic",
3512                &local_var_str
3513                    .into_iter()
3514                    .map(|p| p.to_string())
3515                    .collect::<Vec<String>>()
3516                    .join(",")
3517                    .to_string(),
3518            )]),
3519        };
3520    }
3521    if let Some(ref local_var_str) = name__nie {
3522        local_var_req_builder = match "multi" {
3523            "multi" => local_var_req_builder.query(
3524                &local_var_str
3525                    .into_iter()
3526                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3528            ),
3529            _ => local_var_req_builder.query(&[(
3530                "name__nie",
3531                &local_var_str
3532                    .into_iter()
3533                    .map(|p| p.to_string())
3534                    .collect::<Vec<String>>()
3535                    .join(",")
3536                    .to_string(),
3537            )]),
3538        };
3539    }
3540    if let Some(ref local_var_str) = name__niew {
3541        local_var_req_builder = match "multi" {
3542            "multi" => local_var_req_builder.query(
3543                &local_var_str
3544                    .into_iter()
3545                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3547            ),
3548            _ => local_var_req_builder.query(&[(
3549                "name__niew",
3550                &local_var_str
3551                    .into_iter()
3552                    .map(|p| p.to_string())
3553                    .collect::<Vec<String>>()
3554                    .join(",")
3555                    .to_string(),
3556            )]),
3557        };
3558    }
3559    if let Some(ref local_var_str) = name__nisw {
3560        local_var_req_builder = match "multi" {
3561            "multi" => local_var_req_builder.query(
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3566            ),
3567            _ => local_var_req_builder.query(&[(
3568                "name__nisw",
3569                &local_var_str
3570                    .into_iter()
3571                    .map(|p| p.to_string())
3572                    .collect::<Vec<String>>()
3573                    .join(",")
3574                    .to_string(),
3575            )]),
3576        };
3577    }
3578    if let Some(ref local_var_str) = name__regex {
3579        local_var_req_builder = match "multi" {
3580            "multi" => local_var_req_builder.query(
3581                &local_var_str
3582                    .into_iter()
3583                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3585            ),
3586            _ => local_var_req_builder.query(&[(
3587                "name__regex",
3588                &local_var_str
3589                    .into_iter()
3590                    .map(|p| p.to_string())
3591                    .collect::<Vec<String>>()
3592                    .join(",")
3593                    .to_string(),
3594            )]),
3595        };
3596    }
3597    if let Some(ref local_var_str) = offset {
3598        local_var_req_builder =
3599            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3600    }
3601    if let Some(ref local_var_str) = ordering {
3602        local_var_req_builder =
3603            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3604    }
3605    if let Some(ref local_var_str) = owner {
3606        local_var_req_builder = match "multi" {
3607            "multi" => local_var_req_builder.query(
3608                &local_var_str
3609                    .into_iter()
3610                    .map(|p| ("owner".to_owned(), p.to_string()))
3611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3612            ),
3613            _ => local_var_req_builder.query(&[(
3614                "owner",
3615                &local_var_str
3616                    .into_iter()
3617                    .map(|p| p.to_string())
3618                    .collect::<Vec<String>>()
3619                    .join(",")
3620                    .to_string(),
3621            )]),
3622        };
3623    }
3624    if let Some(ref local_var_str) = owner__n {
3625        local_var_req_builder = match "multi" {
3626            "multi" => local_var_req_builder.query(
3627                &local_var_str
3628                    .into_iter()
3629                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3631            ),
3632            _ => local_var_req_builder.query(&[(
3633                "owner__n",
3634                &local_var_str
3635                    .into_iter()
3636                    .map(|p| p.to_string())
3637                    .collect::<Vec<String>>()
3638                    .join(",")
3639                    .to_string(),
3640            )]),
3641        };
3642    }
3643    if let Some(ref local_var_str) = owner_group {
3644        local_var_req_builder = match "multi" {
3645            "multi" => local_var_req_builder.query(
3646                &local_var_str
3647                    .into_iter()
3648                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3650            ),
3651            _ => local_var_req_builder.query(&[(
3652                "owner_group",
3653                &local_var_str
3654                    .into_iter()
3655                    .map(|p| p.to_string())
3656                    .collect::<Vec<String>>()
3657                    .join(",")
3658                    .to_string(),
3659            )]),
3660        };
3661    }
3662    if let Some(ref local_var_str) = owner_group__n {
3663        local_var_req_builder = match "multi" {
3664            "multi" => local_var_req_builder.query(
3665                &local_var_str
3666                    .into_iter()
3667                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3669            ),
3670            _ => local_var_req_builder.query(&[(
3671                "owner_group__n",
3672                &local_var_str
3673                    .into_iter()
3674                    .map(|p| p.to_string())
3675                    .collect::<Vec<String>>()
3676                    .join(",")
3677                    .to_string(),
3678            )]),
3679        };
3680    }
3681    if let Some(ref local_var_str) = owner_group_id {
3682        local_var_req_builder = match "multi" {
3683            "multi" => local_var_req_builder.query(
3684                &local_var_str
3685                    .into_iter()
3686                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3688            ),
3689            _ => local_var_req_builder.query(&[(
3690                "owner_group_id",
3691                &local_var_str
3692                    .into_iter()
3693                    .map(|p| p.to_string())
3694                    .collect::<Vec<String>>()
3695                    .join(",")
3696                    .to_string(),
3697            )]),
3698        };
3699    }
3700    if let Some(ref local_var_str) = owner_group_id__n {
3701        local_var_req_builder = match "multi" {
3702            "multi" => local_var_req_builder.query(
3703                &local_var_str
3704                    .into_iter()
3705                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3707            ),
3708            _ => local_var_req_builder.query(&[(
3709                "owner_group_id__n",
3710                &local_var_str
3711                    .into_iter()
3712                    .map(|p| p.to_string())
3713                    .collect::<Vec<String>>()
3714                    .join(",")
3715                    .to_string(),
3716            )]),
3717        };
3718    }
3719    if let Some(ref local_var_str) = owner_id {
3720        local_var_req_builder = match "multi" {
3721            "multi" => local_var_req_builder.query(
3722                &local_var_str
3723                    .into_iter()
3724                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3726            ),
3727            _ => local_var_req_builder.query(&[(
3728                "owner_id",
3729                &local_var_str
3730                    .into_iter()
3731                    .map(|p| p.to_string())
3732                    .collect::<Vec<String>>()
3733                    .join(",")
3734                    .to_string(),
3735            )]),
3736        };
3737    }
3738    if let Some(ref local_var_str) = owner_id__n {
3739        local_var_req_builder = match "multi" {
3740            "multi" => local_var_req_builder.query(
3741                &local_var_str
3742                    .into_iter()
3743                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3745            ),
3746            _ => local_var_req_builder.query(&[(
3747                "owner_id__n",
3748                &local_var_str
3749                    .into_iter()
3750                    .map(|p| p.to_string())
3751                    .collect::<Vec<String>>()
3752                    .join(",")
3753                    .to_string(),
3754            )]),
3755        };
3756    }
3757    if let Some(ref local_var_str) = q {
3758        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3759    }
3760    if let Some(ref local_var_str) = slug {
3761        local_var_req_builder = match "multi" {
3762            "multi" => local_var_req_builder.query(
3763                &local_var_str
3764                    .into_iter()
3765                    .map(|p| ("slug".to_owned(), p.to_string()))
3766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3767            ),
3768            _ => local_var_req_builder.query(&[(
3769                "slug",
3770                &local_var_str
3771                    .into_iter()
3772                    .map(|p| p.to_string())
3773                    .collect::<Vec<String>>()
3774                    .join(",")
3775                    .to_string(),
3776            )]),
3777        };
3778    }
3779    if let Some(ref local_var_str) = slug__empty {
3780        local_var_req_builder =
3781            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3782    }
3783    if let Some(ref local_var_str) = slug__ic {
3784        local_var_req_builder = match "multi" {
3785            "multi" => local_var_req_builder.query(
3786                &local_var_str
3787                    .into_iter()
3788                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3790            ),
3791            _ => local_var_req_builder.query(&[(
3792                "slug__ic",
3793                &local_var_str
3794                    .into_iter()
3795                    .map(|p| p.to_string())
3796                    .collect::<Vec<String>>()
3797                    .join(",")
3798                    .to_string(),
3799            )]),
3800        };
3801    }
3802    if let Some(ref local_var_str) = slug__ie {
3803        local_var_req_builder = match "multi" {
3804            "multi" => local_var_req_builder.query(
3805                &local_var_str
3806                    .into_iter()
3807                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3809            ),
3810            _ => local_var_req_builder.query(&[(
3811                "slug__ie",
3812                &local_var_str
3813                    .into_iter()
3814                    .map(|p| p.to_string())
3815                    .collect::<Vec<String>>()
3816                    .join(",")
3817                    .to_string(),
3818            )]),
3819        };
3820    }
3821    if let Some(ref local_var_str) = slug__iew {
3822        local_var_req_builder = match "multi" {
3823            "multi" => local_var_req_builder.query(
3824                &local_var_str
3825                    .into_iter()
3826                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3828            ),
3829            _ => local_var_req_builder.query(&[(
3830                "slug__iew",
3831                &local_var_str
3832                    .into_iter()
3833                    .map(|p| p.to_string())
3834                    .collect::<Vec<String>>()
3835                    .join(",")
3836                    .to_string(),
3837            )]),
3838        };
3839    }
3840    if let Some(ref local_var_str) = slug__iregex {
3841        local_var_req_builder = match "multi" {
3842            "multi" => local_var_req_builder.query(
3843                &local_var_str
3844                    .into_iter()
3845                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3847            ),
3848            _ => local_var_req_builder.query(&[(
3849                "slug__iregex",
3850                &local_var_str
3851                    .into_iter()
3852                    .map(|p| p.to_string())
3853                    .collect::<Vec<String>>()
3854                    .join(",")
3855                    .to_string(),
3856            )]),
3857        };
3858    }
3859    if let Some(ref local_var_str) = slug__isw {
3860        local_var_req_builder = match "multi" {
3861            "multi" => local_var_req_builder.query(
3862                &local_var_str
3863                    .into_iter()
3864                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3866            ),
3867            _ => local_var_req_builder.query(&[(
3868                "slug__isw",
3869                &local_var_str
3870                    .into_iter()
3871                    .map(|p| p.to_string())
3872                    .collect::<Vec<String>>()
3873                    .join(",")
3874                    .to_string(),
3875            )]),
3876        };
3877    }
3878    if let Some(ref local_var_str) = slug__n {
3879        local_var_req_builder = match "multi" {
3880            "multi" => local_var_req_builder.query(
3881                &local_var_str
3882                    .into_iter()
3883                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3885            ),
3886            _ => local_var_req_builder.query(&[(
3887                "slug__n",
3888                &local_var_str
3889                    .into_iter()
3890                    .map(|p| p.to_string())
3891                    .collect::<Vec<String>>()
3892                    .join(",")
3893                    .to_string(),
3894            )]),
3895        };
3896    }
3897    if let Some(ref local_var_str) = slug__nic {
3898        local_var_req_builder = match "multi" {
3899            "multi" => local_var_req_builder.query(
3900                &local_var_str
3901                    .into_iter()
3902                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3904            ),
3905            _ => local_var_req_builder.query(&[(
3906                "slug__nic",
3907                &local_var_str
3908                    .into_iter()
3909                    .map(|p| p.to_string())
3910                    .collect::<Vec<String>>()
3911                    .join(",")
3912                    .to_string(),
3913            )]),
3914        };
3915    }
3916    if let Some(ref local_var_str) = slug__nie {
3917        local_var_req_builder = match "multi" {
3918            "multi" => local_var_req_builder.query(
3919                &local_var_str
3920                    .into_iter()
3921                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3923            ),
3924            _ => local_var_req_builder.query(&[(
3925                "slug__nie",
3926                &local_var_str
3927                    .into_iter()
3928                    .map(|p| p.to_string())
3929                    .collect::<Vec<String>>()
3930                    .join(",")
3931                    .to_string(),
3932            )]),
3933        };
3934    }
3935    if let Some(ref local_var_str) = slug__niew {
3936        local_var_req_builder = match "multi" {
3937            "multi" => local_var_req_builder.query(
3938                &local_var_str
3939                    .into_iter()
3940                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3942            ),
3943            _ => local_var_req_builder.query(&[(
3944                "slug__niew",
3945                &local_var_str
3946                    .into_iter()
3947                    .map(|p| p.to_string())
3948                    .collect::<Vec<String>>()
3949                    .join(",")
3950                    .to_string(),
3951            )]),
3952        };
3953    }
3954    if let Some(ref local_var_str) = slug__nisw {
3955        local_var_req_builder = match "multi" {
3956            "multi" => local_var_req_builder.query(
3957                &local_var_str
3958                    .into_iter()
3959                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3961            ),
3962            _ => local_var_req_builder.query(&[(
3963                "slug__nisw",
3964                &local_var_str
3965                    .into_iter()
3966                    .map(|p| p.to_string())
3967                    .collect::<Vec<String>>()
3968                    .join(",")
3969                    .to_string(),
3970            )]),
3971        };
3972    }
3973    if let Some(ref local_var_str) = slug__regex {
3974        local_var_req_builder = match "multi" {
3975            "multi" => local_var_req_builder.query(
3976                &local_var_str
3977                    .into_iter()
3978                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3980            ),
3981            _ => local_var_req_builder.query(&[(
3982                "slug__regex",
3983                &local_var_str
3984                    .into_iter()
3985                    .map(|p| p.to_string())
3986                    .collect::<Vec<String>>()
3987                    .join(",")
3988                    .to_string(),
3989            )]),
3990        };
3991    }
3992    if let Some(ref local_var_str) = tag {
3993        local_var_req_builder = match "multi" {
3994            "multi" => local_var_req_builder.query(
3995                &local_var_str
3996                    .into_iter()
3997                    .map(|p| ("tag".to_owned(), p.to_string()))
3998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3999            ),
4000            _ => local_var_req_builder.query(&[(
4001                "tag",
4002                &local_var_str
4003                    .into_iter()
4004                    .map(|p| p.to_string())
4005                    .collect::<Vec<String>>()
4006                    .join(",")
4007                    .to_string(),
4008            )]),
4009        };
4010    }
4011    if let Some(ref local_var_str) = tag__n {
4012        local_var_req_builder = match "multi" {
4013            "multi" => local_var_req_builder.query(
4014                &local_var_str
4015                    .into_iter()
4016                    .map(|p| ("tag__n".to_owned(), p.to_string()))
4017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4018            ),
4019            _ => local_var_req_builder.query(&[(
4020                "tag__n",
4021                &local_var_str
4022                    .into_iter()
4023                    .map(|p| p.to_string())
4024                    .collect::<Vec<String>>()
4025                    .join(",")
4026                    .to_string(),
4027            )]),
4028        };
4029    }
4030    if let Some(ref local_var_str) = tag_id {
4031        local_var_req_builder = match "multi" {
4032            "multi" => local_var_req_builder.query(
4033                &local_var_str
4034                    .into_iter()
4035                    .map(|p| ("tag_id".to_owned(), p.to_string()))
4036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4037            ),
4038            _ => local_var_req_builder.query(&[(
4039                "tag_id",
4040                &local_var_str
4041                    .into_iter()
4042                    .map(|p| p.to_string())
4043                    .collect::<Vec<String>>()
4044                    .join(",")
4045                    .to_string(),
4046            )]),
4047        };
4048    }
4049    if let Some(ref local_var_str) = tag_id__n {
4050        local_var_req_builder = match "multi" {
4051            "multi" => local_var_req_builder.query(
4052                &local_var_str
4053                    .into_iter()
4054                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
4055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4056            ),
4057            _ => local_var_req_builder.query(&[(
4058                "tag_id__n",
4059                &local_var_str
4060                    .into_iter()
4061                    .map(|p| p.to_string())
4062                    .collect::<Vec<String>>()
4063                    .join(",")
4064                    .to_string(),
4065            )]),
4066        };
4067    }
4068    if let Some(ref local_var_str) = updated_by_request {
4069        local_var_req_builder =
4070            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
4071    }
4072    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4073        local_var_req_builder =
4074            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4075    }
4076    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4077        let local_var_key = local_var_apikey.key.clone();
4078        let local_var_value = match local_var_apikey.prefix {
4079            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4080            None => local_var_key,
4081        };
4082        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4083    };
4084
4085    let local_var_req = local_var_req_builder.build()?;
4086    let local_var_resp = local_var_client.execute(local_var_req).await?;
4087
4088    let local_var_status = local_var_resp.status();
4089    let local_var_content = local_var_resp.text().await?;
4090
4091    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4092        serde_json::from_str(&local_var_content).map_err(Error::from)
4093    } else {
4094        let local_var_entity: Option<VirtualizationClusterTypesListError> =
4095            serde_json::from_str(&local_var_content).ok();
4096        let local_var_error = ResponseContent {
4097            status: local_var_status,
4098            content: local_var_content,
4099            entity: local_var_entity,
4100        };
4101        Err(Error::ResponseError(local_var_error))
4102    }
4103}
4104
4105/// Patch a cluster type object.
4106pub async fn virtualization_cluster_types_partial_update(
4107    configuration: &configuration::Configuration,
4108    id: i32,
4109    patched_cluster_type_request: Option<crate::models::PatchedClusterTypeRequest>,
4110) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesPartialUpdateError>> {
4111    let local_var_configuration = configuration;
4112
4113    let local_var_client = &local_var_configuration.client;
4114
4115    let local_var_uri_str = format!(
4116        "{}/api/virtualization/cluster-types/{id}/",
4117        local_var_configuration.base_path,
4118        id = id
4119    );
4120    let mut local_var_req_builder =
4121        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4122
4123    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4124        local_var_req_builder =
4125            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4126    }
4127    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4128        let local_var_key = local_var_apikey.key.clone();
4129        let local_var_value = match local_var_apikey.prefix {
4130            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4131            None => local_var_key,
4132        };
4133        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4134    };
4135    local_var_req_builder = local_var_req_builder.json(&patched_cluster_type_request);
4136
4137    let local_var_req = local_var_req_builder.build()?;
4138    let local_var_resp = local_var_client.execute(local_var_req).await?;
4139
4140    let local_var_status = local_var_resp.status();
4141    let local_var_content = local_var_resp.text().await?;
4142
4143    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4144        serde_json::from_str(&local_var_content).map_err(Error::from)
4145    } else {
4146        let local_var_entity: Option<VirtualizationClusterTypesPartialUpdateError> =
4147            serde_json::from_str(&local_var_content).ok();
4148        let local_var_error = ResponseContent {
4149            status: local_var_status,
4150            content: local_var_content,
4151            entity: local_var_entity,
4152        };
4153        Err(Error::ResponseError(local_var_error))
4154    }
4155}
4156
4157/// Get a cluster type object.
4158pub async fn virtualization_cluster_types_retrieve(
4159    configuration: &configuration::Configuration,
4160    id: i32,
4161) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesRetrieveError>> {
4162    let local_var_configuration = configuration;
4163
4164    let local_var_client = &local_var_configuration.client;
4165
4166    let local_var_uri_str = format!(
4167        "{}/api/virtualization/cluster-types/{id}/",
4168        local_var_configuration.base_path,
4169        id = id
4170    );
4171    let mut local_var_req_builder =
4172        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4173
4174    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4175        local_var_req_builder =
4176            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4177    }
4178    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4179        let local_var_key = local_var_apikey.key.clone();
4180        let local_var_value = match local_var_apikey.prefix {
4181            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4182            None => local_var_key,
4183        };
4184        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4185    };
4186
4187    let local_var_req = local_var_req_builder.build()?;
4188    let local_var_resp = local_var_client.execute(local_var_req).await?;
4189
4190    let local_var_status = local_var_resp.status();
4191    let local_var_content = local_var_resp.text().await?;
4192
4193    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4194        serde_json::from_str(&local_var_content).map_err(Error::from)
4195    } else {
4196        let local_var_entity: Option<VirtualizationClusterTypesRetrieveError> =
4197            serde_json::from_str(&local_var_content).ok();
4198        let local_var_error = ResponseContent {
4199            status: local_var_status,
4200            content: local_var_content,
4201            entity: local_var_entity,
4202        };
4203        Err(Error::ResponseError(local_var_error))
4204    }
4205}
4206
4207/// Put a cluster type object.
4208pub async fn virtualization_cluster_types_update(
4209    configuration: &configuration::Configuration,
4210    id: i32,
4211    cluster_type_request: crate::models::ClusterTypeRequest,
4212) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesUpdateError>> {
4213    let local_var_configuration = configuration;
4214
4215    let local_var_client = &local_var_configuration.client;
4216
4217    let local_var_uri_str = format!(
4218        "{}/api/virtualization/cluster-types/{id}/",
4219        local_var_configuration.base_path,
4220        id = id
4221    );
4222    let mut local_var_req_builder =
4223        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4224
4225    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4226        local_var_req_builder =
4227            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4228    }
4229    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4230        let local_var_key = local_var_apikey.key.clone();
4231        let local_var_value = match local_var_apikey.prefix {
4232            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4233            None => local_var_key,
4234        };
4235        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4236    };
4237    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
4238
4239    let local_var_req = local_var_req_builder.build()?;
4240    let local_var_resp = local_var_client.execute(local_var_req).await?;
4241
4242    let local_var_status = local_var_resp.status();
4243    let local_var_content = local_var_resp.text().await?;
4244
4245    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4246        serde_json::from_str(&local_var_content).map_err(Error::from)
4247    } else {
4248        let local_var_entity: Option<VirtualizationClusterTypesUpdateError> =
4249            serde_json::from_str(&local_var_content).ok();
4250        let local_var_error = ResponseContent {
4251            status: local_var_status,
4252            content: local_var_content,
4253            entity: local_var_entity,
4254        };
4255        Err(Error::ResponseError(local_var_error))
4256    }
4257}
4258
4259/// Delete a list of cluster objects.
4260pub async fn virtualization_clusters_bulk_destroy(
4261    configuration: &configuration::Configuration,
4262    cluster_request: Vec<crate::models::ClusterRequest>,
4263) -> Result<(), Error<VirtualizationClustersBulkDestroyError>> {
4264    let local_var_configuration = configuration;
4265
4266    let local_var_client = &local_var_configuration.client;
4267
4268    let local_var_uri_str = format!(
4269        "{}/api/virtualization/clusters/",
4270        local_var_configuration.base_path
4271    );
4272    let mut local_var_req_builder =
4273        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4274
4275    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4276        local_var_req_builder =
4277            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4278    }
4279    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4280        let local_var_key = local_var_apikey.key.clone();
4281        let local_var_value = match local_var_apikey.prefix {
4282            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4283            None => local_var_key,
4284        };
4285        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4286    };
4287    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4288
4289    let local_var_req = local_var_req_builder.build()?;
4290    let local_var_resp = local_var_client.execute(local_var_req).await?;
4291
4292    let local_var_status = local_var_resp.status();
4293    let local_var_content = local_var_resp.text().await?;
4294
4295    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4296        Ok(())
4297    } else {
4298        let local_var_entity: Option<VirtualizationClustersBulkDestroyError> =
4299            serde_json::from_str(&local_var_content).ok();
4300        let local_var_error = ResponseContent {
4301            status: local_var_status,
4302            content: local_var_content,
4303            entity: local_var_entity,
4304        };
4305        Err(Error::ResponseError(local_var_error))
4306    }
4307}
4308
4309/// Patch a list of cluster objects.
4310pub async fn virtualization_clusters_bulk_partial_update(
4311    configuration: &configuration::Configuration,
4312    cluster_request: Vec<crate::models::ClusterRequest>,
4313) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkPartialUpdateError>> {
4314    let local_var_configuration = configuration;
4315
4316    let local_var_client = &local_var_configuration.client;
4317
4318    let local_var_uri_str = format!(
4319        "{}/api/virtualization/clusters/",
4320        local_var_configuration.base_path
4321    );
4322    let mut local_var_req_builder =
4323        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4324
4325    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4326        local_var_req_builder =
4327            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4328    }
4329    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4330        let local_var_key = local_var_apikey.key.clone();
4331        let local_var_value = match local_var_apikey.prefix {
4332            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4333            None => local_var_key,
4334        };
4335        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4336    };
4337    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4338
4339    let local_var_req = local_var_req_builder.build()?;
4340    let local_var_resp = local_var_client.execute(local_var_req).await?;
4341
4342    let local_var_status = local_var_resp.status();
4343    let local_var_content = local_var_resp.text().await?;
4344
4345    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4346        serde_json::from_str(&local_var_content).map_err(Error::from)
4347    } else {
4348        let local_var_entity: Option<VirtualizationClustersBulkPartialUpdateError> =
4349            serde_json::from_str(&local_var_content).ok();
4350        let local_var_error = ResponseContent {
4351            status: local_var_status,
4352            content: local_var_content,
4353            entity: local_var_entity,
4354        };
4355        Err(Error::ResponseError(local_var_error))
4356    }
4357}
4358
4359/// Put a list of cluster objects.
4360pub async fn virtualization_clusters_bulk_update(
4361    configuration: &configuration::Configuration,
4362    cluster_request: Vec<crate::models::ClusterRequest>,
4363) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkUpdateError>> {
4364    let local_var_configuration = configuration;
4365
4366    let local_var_client = &local_var_configuration.client;
4367
4368    let local_var_uri_str = format!(
4369        "{}/api/virtualization/clusters/",
4370        local_var_configuration.base_path
4371    );
4372    let mut local_var_req_builder =
4373        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4374
4375    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4376        local_var_req_builder =
4377            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4378    }
4379    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4380        let local_var_key = local_var_apikey.key.clone();
4381        let local_var_value = match local_var_apikey.prefix {
4382            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4383            None => local_var_key,
4384        };
4385        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4386    };
4387    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4388
4389    let local_var_req = local_var_req_builder.build()?;
4390    let local_var_resp = local_var_client.execute(local_var_req).await?;
4391
4392    let local_var_status = local_var_resp.status();
4393    let local_var_content = local_var_resp.text().await?;
4394
4395    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4396        serde_json::from_str(&local_var_content).map_err(Error::from)
4397    } else {
4398        let local_var_entity: Option<VirtualizationClustersBulkUpdateError> =
4399            serde_json::from_str(&local_var_content).ok();
4400        let local_var_error = ResponseContent {
4401            status: local_var_status,
4402            content: local_var_content,
4403            entity: local_var_entity,
4404        };
4405        Err(Error::ResponseError(local_var_error))
4406    }
4407}
4408
4409/// Post a list of cluster objects.
4410pub async fn virtualization_clusters_create(
4411    configuration: &configuration::Configuration,
4412    virtualization_clusters_create_request: crate::models::VirtualizationClustersCreateRequest,
4413) -> Result<crate::models::Cluster, Error<VirtualizationClustersCreateError>> {
4414    let local_var_configuration = configuration;
4415
4416    let local_var_client = &local_var_configuration.client;
4417
4418    let local_var_uri_str = format!(
4419        "{}/api/virtualization/clusters/",
4420        local_var_configuration.base_path
4421    );
4422    let mut local_var_req_builder =
4423        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4424
4425    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4426        local_var_req_builder =
4427            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4428    }
4429    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4430        let local_var_key = local_var_apikey.key.clone();
4431        let local_var_value = match local_var_apikey.prefix {
4432            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4433            None => local_var_key,
4434        };
4435        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4436    };
4437    local_var_req_builder = local_var_req_builder.json(&virtualization_clusters_create_request);
4438
4439    let local_var_req = local_var_req_builder.build()?;
4440    let local_var_resp = local_var_client.execute(local_var_req).await?;
4441
4442    let local_var_status = local_var_resp.status();
4443    let local_var_content = local_var_resp.text().await?;
4444
4445    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4446        serde_json::from_str(&local_var_content).map_err(Error::from)
4447    } else {
4448        let local_var_entity: Option<VirtualizationClustersCreateError> =
4449            serde_json::from_str(&local_var_content).ok();
4450        let local_var_error = ResponseContent {
4451            status: local_var_status,
4452            content: local_var_content,
4453            entity: local_var_entity,
4454        };
4455        Err(Error::ResponseError(local_var_error))
4456    }
4457}
4458
4459/// Delete a cluster object.
4460pub async fn virtualization_clusters_destroy(
4461    configuration: &configuration::Configuration,
4462    id: i32,
4463) -> Result<(), Error<VirtualizationClustersDestroyError>> {
4464    let local_var_configuration = configuration;
4465
4466    let local_var_client = &local_var_configuration.client;
4467
4468    let local_var_uri_str = format!(
4469        "{}/api/virtualization/clusters/{id}/",
4470        local_var_configuration.base_path,
4471        id = id
4472    );
4473    let mut local_var_req_builder =
4474        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4475
4476    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4477        local_var_req_builder =
4478            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4479    }
4480    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4481        let local_var_key = local_var_apikey.key.clone();
4482        let local_var_value = match local_var_apikey.prefix {
4483            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4484            None => local_var_key,
4485        };
4486        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4487    };
4488
4489    let local_var_req = local_var_req_builder.build()?;
4490    let local_var_resp = local_var_client.execute(local_var_req).await?;
4491
4492    let local_var_status = local_var_resp.status();
4493    let local_var_content = local_var_resp.text().await?;
4494
4495    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4496        Ok(())
4497    } else {
4498        let local_var_entity: Option<VirtualizationClustersDestroyError> =
4499            serde_json::from_str(&local_var_content).ok();
4500        let local_var_error = ResponseContent {
4501            status: local_var_status,
4502            content: local_var_content,
4503            entity: local_var_entity,
4504        };
4505        Err(Error::ResponseError(local_var_error))
4506    }
4507}
4508
4509/// Get a list of cluster objects.
4510pub async fn virtualization_clusters_list(
4511    configuration: &configuration::Configuration,
4512    contact: Option<Vec<i32>>,
4513    contact__n: Option<Vec<i32>>,
4514    contact_group: Option<Vec<String>>,
4515    contact_group__n: Option<Vec<String>>,
4516    contact_role: Option<Vec<i32>>,
4517    contact_role__n: Option<Vec<i32>>,
4518    created: Option<Vec<String>>,
4519    created__empty: Option<Vec<String>>,
4520    created__gt: Option<Vec<String>>,
4521    created__gte: Option<Vec<String>>,
4522    created__lt: Option<Vec<String>>,
4523    created__lte: Option<Vec<String>>,
4524    created__n: Option<Vec<String>>,
4525    created_by_request: Option<&str>,
4526    description: Option<Vec<String>>,
4527    description__empty: Option<bool>,
4528    description__ic: Option<Vec<String>>,
4529    description__ie: Option<Vec<String>>,
4530    description__iew: Option<Vec<String>>,
4531    description__iregex: Option<Vec<String>>,
4532    description__isw: Option<Vec<String>>,
4533    description__n: Option<Vec<String>>,
4534    description__nic: Option<Vec<String>>,
4535    description__nie: Option<Vec<String>>,
4536    description__niew: Option<Vec<String>>,
4537    description__nisw: Option<Vec<String>>,
4538    description__regex: Option<Vec<String>>,
4539    group: Option<Vec<String>>,
4540    group__n: Option<Vec<String>>,
4541    group_id: Option<Vec<i32>>,
4542    group_id__n: Option<Vec<i32>>,
4543    id: Option<Vec<i32>>,
4544    id__empty: Option<bool>,
4545    id__gt: Option<Vec<i32>>,
4546    id__gte: Option<Vec<i32>>,
4547    id__lt: Option<Vec<i32>>,
4548    id__lte: Option<Vec<i32>>,
4549    id__n: Option<Vec<i32>>,
4550    last_updated: Option<Vec<String>>,
4551    last_updated__empty: Option<Vec<String>>,
4552    last_updated__gt: Option<Vec<String>>,
4553    last_updated__gte: Option<Vec<String>>,
4554    last_updated__lt: Option<Vec<String>>,
4555    last_updated__lte: Option<Vec<String>>,
4556    last_updated__n: Option<Vec<String>>,
4557    limit: Option<i32>,
4558    location: Option<Vec<String>>,
4559    location__n: Option<Vec<String>>,
4560    location_id: Option<Vec<String>>,
4561    location_id__n: Option<Vec<String>>,
4562    modified_by_request: Option<&str>,
4563    name: Option<Vec<String>>,
4564    name__empty: Option<bool>,
4565    name__ic: Option<Vec<String>>,
4566    name__ie: Option<Vec<String>>,
4567    name__iew: Option<Vec<String>>,
4568    name__iregex: Option<Vec<String>>,
4569    name__isw: Option<Vec<String>>,
4570    name__n: Option<Vec<String>>,
4571    name__nic: Option<Vec<String>>,
4572    name__nie: Option<Vec<String>>,
4573    name__niew: Option<Vec<String>>,
4574    name__nisw: Option<Vec<String>>,
4575    name__regex: Option<Vec<String>>,
4576    offset: Option<i32>,
4577    ordering: Option<&str>,
4578    owner: Option<Vec<String>>,
4579    owner__n: Option<Vec<String>>,
4580    owner_group: Option<Vec<String>>,
4581    owner_group__n: Option<Vec<String>>,
4582    owner_group_id: Option<Vec<i32>>,
4583    owner_group_id__n: Option<Vec<i32>>,
4584    owner_id: Option<Vec<i32>>,
4585    owner_id__n: Option<Vec<i32>>,
4586    q: Option<&str>,
4587    region: Option<Vec<String>>,
4588    region__n: Option<Vec<String>>,
4589    region_id: Option<Vec<String>>,
4590    region_id__n: Option<Vec<String>>,
4591    scope_id: Option<Vec<i32>>,
4592    scope_id__empty: Option<bool>,
4593    scope_id__gt: Option<Vec<i32>>,
4594    scope_id__gte: Option<Vec<i32>>,
4595    scope_id__lt: Option<Vec<i32>>,
4596    scope_id__lte: Option<Vec<i32>>,
4597    scope_id__n: Option<Vec<i32>>,
4598    scope_type: Option<Vec<String>>,
4599    scope_type__n: Option<Vec<String>>,
4600    site: Option<Vec<String>>,
4601    site__n: Option<Vec<String>>,
4602    site_group: Option<Vec<String>>,
4603    site_group__n: Option<Vec<String>>,
4604    site_group_id: Option<Vec<String>>,
4605    site_group_id__n: Option<Vec<String>>,
4606    site_id: Option<Vec<i32>>,
4607    site_id__n: Option<Vec<i32>>,
4608    status: Option<Vec<String>>,
4609    status__empty: Option<bool>,
4610    status__ic: Option<Vec<String>>,
4611    status__ie: Option<Vec<String>>,
4612    status__iew: Option<Vec<String>>,
4613    status__iregex: Option<Vec<String>>,
4614    status__isw: Option<Vec<String>>,
4615    status__n: Option<Vec<String>>,
4616    status__nic: Option<Vec<String>>,
4617    status__nie: Option<Vec<String>>,
4618    status__niew: Option<Vec<String>>,
4619    status__nisw: Option<Vec<String>>,
4620    status__regex: Option<Vec<String>>,
4621    tag: Option<Vec<String>>,
4622    tag__n: Option<Vec<String>>,
4623    tag_id: Option<Vec<i32>>,
4624    tag_id__n: Option<Vec<i32>>,
4625    tenant: Option<Vec<String>>,
4626    tenant__n: Option<Vec<String>>,
4627    tenant_group: Option<Vec<String>>,
4628    tenant_group__n: Option<Vec<String>>,
4629    tenant_group_id: Option<Vec<String>>,
4630    tenant_group_id__n: Option<Vec<String>>,
4631    tenant_id: Option<Vec<i32>>,
4632    tenant_id__n: Option<Vec<i32>>,
4633    r#type: Option<Vec<String>>,
4634    type__n: Option<Vec<String>>,
4635    type_id: Option<Vec<i32>>,
4636    type_id__n: Option<Vec<i32>>,
4637    updated_by_request: Option<&str>,
4638) -> Result<crate::models::PaginatedClusterList, Error<VirtualizationClustersListError>> {
4639    let local_var_configuration = configuration;
4640
4641    let local_var_client = &local_var_configuration.client;
4642
4643    let local_var_uri_str = format!(
4644        "{}/api/virtualization/clusters/",
4645        local_var_configuration.base_path
4646    );
4647    let mut local_var_req_builder =
4648        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4649
4650    if let Some(ref local_var_str) = contact {
4651        local_var_req_builder = match "multi" {
4652            "multi" => local_var_req_builder.query(
4653                &local_var_str
4654                    .into_iter()
4655                    .map(|p| ("contact".to_owned(), p.to_string()))
4656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4657            ),
4658            _ => local_var_req_builder.query(&[(
4659                "contact",
4660                &local_var_str
4661                    .into_iter()
4662                    .map(|p| p.to_string())
4663                    .collect::<Vec<String>>()
4664                    .join(",")
4665                    .to_string(),
4666            )]),
4667        };
4668    }
4669    if let Some(ref local_var_str) = contact__n {
4670        local_var_req_builder = match "multi" {
4671            "multi" => local_var_req_builder.query(
4672                &local_var_str
4673                    .into_iter()
4674                    .map(|p| ("contact__n".to_owned(), p.to_string()))
4675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4676            ),
4677            _ => local_var_req_builder.query(&[(
4678                "contact__n",
4679                &local_var_str
4680                    .into_iter()
4681                    .map(|p| p.to_string())
4682                    .collect::<Vec<String>>()
4683                    .join(",")
4684                    .to_string(),
4685            )]),
4686        };
4687    }
4688    if let Some(ref local_var_str) = contact_group {
4689        local_var_req_builder = match "multi" {
4690            "multi" => local_var_req_builder.query(
4691                &local_var_str
4692                    .into_iter()
4693                    .map(|p| ("contact_group".to_owned(), p.to_string()))
4694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4695            ),
4696            _ => local_var_req_builder.query(&[(
4697                "contact_group",
4698                &local_var_str
4699                    .into_iter()
4700                    .map(|p| p.to_string())
4701                    .collect::<Vec<String>>()
4702                    .join(",")
4703                    .to_string(),
4704            )]),
4705        };
4706    }
4707    if let Some(ref local_var_str) = contact_group__n {
4708        local_var_req_builder = match "multi" {
4709            "multi" => local_var_req_builder.query(
4710                &local_var_str
4711                    .into_iter()
4712                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
4713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4714            ),
4715            _ => local_var_req_builder.query(&[(
4716                "contact_group__n",
4717                &local_var_str
4718                    .into_iter()
4719                    .map(|p| p.to_string())
4720                    .collect::<Vec<String>>()
4721                    .join(",")
4722                    .to_string(),
4723            )]),
4724        };
4725    }
4726    if let Some(ref local_var_str) = contact_role {
4727        local_var_req_builder = match "multi" {
4728            "multi" => local_var_req_builder.query(
4729                &local_var_str
4730                    .into_iter()
4731                    .map(|p| ("contact_role".to_owned(), p.to_string()))
4732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4733            ),
4734            _ => local_var_req_builder.query(&[(
4735                "contact_role",
4736                &local_var_str
4737                    .into_iter()
4738                    .map(|p| p.to_string())
4739                    .collect::<Vec<String>>()
4740                    .join(",")
4741                    .to_string(),
4742            )]),
4743        };
4744    }
4745    if let Some(ref local_var_str) = contact_role__n {
4746        local_var_req_builder = match "multi" {
4747            "multi" => local_var_req_builder.query(
4748                &local_var_str
4749                    .into_iter()
4750                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
4751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4752            ),
4753            _ => local_var_req_builder.query(&[(
4754                "contact_role__n",
4755                &local_var_str
4756                    .into_iter()
4757                    .map(|p| p.to_string())
4758                    .collect::<Vec<String>>()
4759                    .join(",")
4760                    .to_string(),
4761            )]),
4762        };
4763    }
4764    if let Some(ref local_var_str) = created {
4765        local_var_req_builder = match "multi" {
4766            "multi" => local_var_req_builder.query(
4767                &local_var_str
4768                    .into_iter()
4769                    .map(|p| ("created".to_owned(), p.to_string()))
4770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4771            ),
4772            _ => local_var_req_builder.query(&[(
4773                "created",
4774                &local_var_str
4775                    .into_iter()
4776                    .map(|p| p.to_string())
4777                    .collect::<Vec<String>>()
4778                    .join(",")
4779                    .to_string(),
4780            )]),
4781        };
4782    }
4783    if let Some(ref local_var_str) = created__empty {
4784        local_var_req_builder = match "multi" {
4785            "multi" => local_var_req_builder.query(
4786                &local_var_str
4787                    .into_iter()
4788                    .map(|p| ("created__empty".to_owned(), p.to_string()))
4789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4790            ),
4791            _ => local_var_req_builder.query(&[(
4792                "created__empty",
4793                &local_var_str
4794                    .into_iter()
4795                    .map(|p| p.to_string())
4796                    .collect::<Vec<String>>()
4797                    .join(",")
4798                    .to_string(),
4799            )]),
4800        };
4801    }
4802    if let Some(ref local_var_str) = created__gt {
4803        local_var_req_builder = match "multi" {
4804            "multi" => local_var_req_builder.query(
4805                &local_var_str
4806                    .into_iter()
4807                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4809            ),
4810            _ => local_var_req_builder.query(&[(
4811                "created__gt",
4812                &local_var_str
4813                    .into_iter()
4814                    .map(|p| p.to_string())
4815                    .collect::<Vec<String>>()
4816                    .join(",")
4817                    .to_string(),
4818            )]),
4819        };
4820    }
4821    if let Some(ref local_var_str) = created__gte {
4822        local_var_req_builder = match "multi" {
4823            "multi" => local_var_req_builder.query(
4824                &local_var_str
4825                    .into_iter()
4826                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4828            ),
4829            _ => local_var_req_builder.query(&[(
4830                "created__gte",
4831                &local_var_str
4832                    .into_iter()
4833                    .map(|p| p.to_string())
4834                    .collect::<Vec<String>>()
4835                    .join(",")
4836                    .to_string(),
4837            )]),
4838        };
4839    }
4840    if let Some(ref local_var_str) = created__lt {
4841        local_var_req_builder = match "multi" {
4842            "multi" => local_var_req_builder.query(
4843                &local_var_str
4844                    .into_iter()
4845                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4847            ),
4848            _ => local_var_req_builder.query(&[(
4849                "created__lt",
4850                &local_var_str
4851                    .into_iter()
4852                    .map(|p| p.to_string())
4853                    .collect::<Vec<String>>()
4854                    .join(",")
4855                    .to_string(),
4856            )]),
4857        };
4858    }
4859    if let Some(ref local_var_str) = created__lte {
4860        local_var_req_builder = match "multi" {
4861            "multi" => local_var_req_builder.query(
4862                &local_var_str
4863                    .into_iter()
4864                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4866            ),
4867            _ => local_var_req_builder.query(&[(
4868                "created__lte",
4869                &local_var_str
4870                    .into_iter()
4871                    .map(|p| p.to_string())
4872                    .collect::<Vec<String>>()
4873                    .join(",")
4874                    .to_string(),
4875            )]),
4876        };
4877    }
4878    if let Some(ref local_var_str) = created__n {
4879        local_var_req_builder = match "multi" {
4880            "multi" => local_var_req_builder.query(
4881                &local_var_str
4882                    .into_iter()
4883                    .map(|p| ("created__n".to_owned(), p.to_string()))
4884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4885            ),
4886            _ => local_var_req_builder.query(&[(
4887                "created__n",
4888                &local_var_str
4889                    .into_iter()
4890                    .map(|p| p.to_string())
4891                    .collect::<Vec<String>>()
4892                    .join(",")
4893                    .to_string(),
4894            )]),
4895        };
4896    }
4897    if let Some(ref local_var_str) = created_by_request {
4898        local_var_req_builder =
4899            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4900    }
4901    if let Some(ref local_var_str) = description {
4902        local_var_req_builder = match "multi" {
4903            "multi" => local_var_req_builder.query(
4904                &local_var_str
4905                    .into_iter()
4906                    .map(|p| ("description".to_owned(), p.to_string()))
4907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4908            ),
4909            _ => local_var_req_builder.query(&[(
4910                "description",
4911                &local_var_str
4912                    .into_iter()
4913                    .map(|p| p.to_string())
4914                    .collect::<Vec<String>>()
4915                    .join(",")
4916                    .to_string(),
4917            )]),
4918        };
4919    }
4920    if let Some(ref local_var_str) = description__empty {
4921        local_var_req_builder =
4922            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4923    }
4924    if let Some(ref local_var_str) = description__ic {
4925        local_var_req_builder = match "multi" {
4926            "multi" => local_var_req_builder.query(
4927                &local_var_str
4928                    .into_iter()
4929                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4931            ),
4932            _ => local_var_req_builder.query(&[(
4933                "description__ic",
4934                &local_var_str
4935                    .into_iter()
4936                    .map(|p| p.to_string())
4937                    .collect::<Vec<String>>()
4938                    .join(",")
4939                    .to_string(),
4940            )]),
4941        };
4942    }
4943    if let Some(ref local_var_str) = description__ie {
4944        local_var_req_builder = match "multi" {
4945            "multi" => local_var_req_builder.query(
4946                &local_var_str
4947                    .into_iter()
4948                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4950            ),
4951            _ => local_var_req_builder.query(&[(
4952                "description__ie",
4953                &local_var_str
4954                    .into_iter()
4955                    .map(|p| p.to_string())
4956                    .collect::<Vec<String>>()
4957                    .join(",")
4958                    .to_string(),
4959            )]),
4960        };
4961    }
4962    if let Some(ref local_var_str) = description__iew {
4963        local_var_req_builder = match "multi" {
4964            "multi" => local_var_req_builder.query(
4965                &local_var_str
4966                    .into_iter()
4967                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4969            ),
4970            _ => local_var_req_builder.query(&[(
4971                "description__iew",
4972                &local_var_str
4973                    .into_iter()
4974                    .map(|p| p.to_string())
4975                    .collect::<Vec<String>>()
4976                    .join(",")
4977                    .to_string(),
4978            )]),
4979        };
4980    }
4981    if let Some(ref local_var_str) = description__iregex {
4982        local_var_req_builder = match "multi" {
4983            "multi" => local_var_req_builder.query(
4984                &local_var_str
4985                    .into_iter()
4986                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4988            ),
4989            _ => local_var_req_builder.query(&[(
4990                "description__iregex",
4991                &local_var_str
4992                    .into_iter()
4993                    .map(|p| p.to_string())
4994                    .collect::<Vec<String>>()
4995                    .join(",")
4996                    .to_string(),
4997            )]),
4998        };
4999    }
5000    if let Some(ref local_var_str) = description__isw {
5001        local_var_req_builder = match "multi" {
5002            "multi" => local_var_req_builder.query(
5003                &local_var_str
5004                    .into_iter()
5005                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5007            ),
5008            _ => local_var_req_builder.query(&[(
5009                "description__isw",
5010                &local_var_str
5011                    .into_iter()
5012                    .map(|p| p.to_string())
5013                    .collect::<Vec<String>>()
5014                    .join(",")
5015                    .to_string(),
5016            )]),
5017        };
5018    }
5019    if let Some(ref local_var_str) = description__n {
5020        local_var_req_builder = match "multi" {
5021            "multi" => local_var_req_builder.query(
5022                &local_var_str
5023                    .into_iter()
5024                    .map(|p| ("description__n".to_owned(), p.to_string()))
5025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5026            ),
5027            _ => local_var_req_builder.query(&[(
5028                "description__n",
5029                &local_var_str
5030                    .into_iter()
5031                    .map(|p| p.to_string())
5032                    .collect::<Vec<String>>()
5033                    .join(",")
5034                    .to_string(),
5035            )]),
5036        };
5037    }
5038    if let Some(ref local_var_str) = description__nic {
5039        local_var_req_builder = match "multi" {
5040            "multi" => local_var_req_builder.query(
5041                &local_var_str
5042                    .into_iter()
5043                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5045            ),
5046            _ => local_var_req_builder.query(&[(
5047                "description__nic",
5048                &local_var_str
5049                    .into_iter()
5050                    .map(|p| p.to_string())
5051                    .collect::<Vec<String>>()
5052                    .join(",")
5053                    .to_string(),
5054            )]),
5055        };
5056    }
5057    if let Some(ref local_var_str) = description__nie {
5058        local_var_req_builder = match "multi" {
5059            "multi" => local_var_req_builder.query(
5060                &local_var_str
5061                    .into_iter()
5062                    .map(|p| ("description__nie".to_owned(), p.to_string()))
5063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5064            ),
5065            _ => local_var_req_builder.query(&[(
5066                "description__nie",
5067                &local_var_str
5068                    .into_iter()
5069                    .map(|p| p.to_string())
5070                    .collect::<Vec<String>>()
5071                    .join(",")
5072                    .to_string(),
5073            )]),
5074        };
5075    }
5076    if let Some(ref local_var_str) = description__niew {
5077        local_var_req_builder = match "multi" {
5078            "multi" => local_var_req_builder.query(
5079                &local_var_str
5080                    .into_iter()
5081                    .map(|p| ("description__niew".to_owned(), p.to_string()))
5082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5083            ),
5084            _ => local_var_req_builder.query(&[(
5085                "description__niew",
5086                &local_var_str
5087                    .into_iter()
5088                    .map(|p| p.to_string())
5089                    .collect::<Vec<String>>()
5090                    .join(",")
5091                    .to_string(),
5092            )]),
5093        };
5094    }
5095    if let Some(ref local_var_str) = description__nisw {
5096        local_var_req_builder = match "multi" {
5097            "multi" => local_var_req_builder.query(
5098                &local_var_str
5099                    .into_iter()
5100                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
5101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5102            ),
5103            _ => local_var_req_builder.query(&[(
5104                "description__nisw",
5105                &local_var_str
5106                    .into_iter()
5107                    .map(|p| p.to_string())
5108                    .collect::<Vec<String>>()
5109                    .join(",")
5110                    .to_string(),
5111            )]),
5112        };
5113    }
5114    if let Some(ref local_var_str) = description__regex {
5115        local_var_req_builder = match "multi" {
5116            "multi" => local_var_req_builder.query(
5117                &local_var_str
5118                    .into_iter()
5119                    .map(|p| ("description__regex".to_owned(), p.to_string()))
5120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5121            ),
5122            _ => local_var_req_builder.query(&[(
5123                "description__regex",
5124                &local_var_str
5125                    .into_iter()
5126                    .map(|p| p.to_string())
5127                    .collect::<Vec<String>>()
5128                    .join(",")
5129                    .to_string(),
5130            )]),
5131        };
5132    }
5133    if let Some(ref local_var_str) = group {
5134        local_var_req_builder = match "multi" {
5135            "multi" => local_var_req_builder.query(
5136                &local_var_str
5137                    .into_iter()
5138                    .map(|p| ("group".to_owned(), p.to_string()))
5139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5140            ),
5141            _ => local_var_req_builder.query(&[(
5142                "group",
5143                &local_var_str
5144                    .into_iter()
5145                    .map(|p| p.to_string())
5146                    .collect::<Vec<String>>()
5147                    .join(",")
5148                    .to_string(),
5149            )]),
5150        };
5151    }
5152    if let Some(ref local_var_str) = group__n {
5153        local_var_req_builder = match "multi" {
5154            "multi" => local_var_req_builder.query(
5155                &local_var_str
5156                    .into_iter()
5157                    .map(|p| ("group__n".to_owned(), p.to_string()))
5158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5159            ),
5160            _ => local_var_req_builder.query(&[(
5161                "group__n",
5162                &local_var_str
5163                    .into_iter()
5164                    .map(|p| p.to_string())
5165                    .collect::<Vec<String>>()
5166                    .join(",")
5167                    .to_string(),
5168            )]),
5169        };
5170    }
5171    if let Some(ref local_var_str) = group_id {
5172        local_var_req_builder = match "multi" {
5173            "multi" => local_var_req_builder.query(
5174                &local_var_str
5175                    .into_iter()
5176                    .map(|p| ("group_id".to_owned(), p.to_string()))
5177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5178            ),
5179            _ => local_var_req_builder.query(&[(
5180                "group_id",
5181                &local_var_str
5182                    .into_iter()
5183                    .map(|p| p.to_string())
5184                    .collect::<Vec<String>>()
5185                    .join(",")
5186                    .to_string(),
5187            )]),
5188        };
5189    }
5190    if let Some(ref local_var_str) = group_id__n {
5191        local_var_req_builder = match "multi" {
5192            "multi" => local_var_req_builder.query(
5193                &local_var_str
5194                    .into_iter()
5195                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
5196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5197            ),
5198            _ => local_var_req_builder.query(&[(
5199                "group_id__n",
5200                &local_var_str
5201                    .into_iter()
5202                    .map(|p| p.to_string())
5203                    .collect::<Vec<String>>()
5204                    .join(",")
5205                    .to_string(),
5206            )]),
5207        };
5208    }
5209    if let Some(ref local_var_str) = id {
5210        local_var_req_builder = match "multi" {
5211            "multi" => local_var_req_builder.query(
5212                &local_var_str
5213                    .into_iter()
5214                    .map(|p| ("id".to_owned(), p.to_string()))
5215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5216            ),
5217            _ => local_var_req_builder.query(&[(
5218                "id",
5219                &local_var_str
5220                    .into_iter()
5221                    .map(|p| p.to_string())
5222                    .collect::<Vec<String>>()
5223                    .join(",")
5224                    .to_string(),
5225            )]),
5226        };
5227    }
5228    if let Some(ref local_var_str) = id__empty {
5229        local_var_req_builder =
5230            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
5231    }
5232    if let Some(ref local_var_str) = id__gt {
5233        local_var_req_builder = match "multi" {
5234            "multi" => local_var_req_builder.query(
5235                &local_var_str
5236                    .into_iter()
5237                    .map(|p| ("id__gt".to_owned(), p.to_string()))
5238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5239            ),
5240            _ => local_var_req_builder.query(&[(
5241                "id__gt",
5242                &local_var_str
5243                    .into_iter()
5244                    .map(|p| p.to_string())
5245                    .collect::<Vec<String>>()
5246                    .join(",")
5247                    .to_string(),
5248            )]),
5249        };
5250    }
5251    if let Some(ref local_var_str) = id__gte {
5252        local_var_req_builder = match "multi" {
5253            "multi" => local_var_req_builder.query(
5254                &local_var_str
5255                    .into_iter()
5256                    .map(|p| ("id__gte".to_owned(), p.to_string()))
5257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5258            ),
5259            _ => local_var_req_builder.query(&[(
5260                "id__gte",
5261                &local_var_str
5262                    .into_iter()
5263                    .map(|p| p.to_string())
5264                    .collect::<Vec<String>>()
5265                    .join(",")
5266                    .to_string(),
5267            )]),
5268        };
5269    }
5270    if let Some(ref local_var_str) = id__lt {
5271        local_var_req_builder = match "multi" {
5272            "multi" => local_var_req_builder.query(
5273                &local_var_str
5274                    .into_iter()
5275                    .map(|p| ("id__lt".to_owned(), p.to_string()))
5276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5277            ),
5278            _ => local_var_req_builder.query(&[(
5279                "id__lt",
5280                &local_var_str
5281                    .into_iter()
5282                    .map(|p| p.to_string())
5283                    .collect::<Vec<String>>()
5284                    .join(",")
5285                    .to_string(),
5286            )]),
5287        };
5288    }
5289    if let Some(ref local_var_str) = id__lte {
5290        local_var_req_builder = match "multi" {
5291            "multi" => local_var_req_builder.query(
5292                &local_var_str
5293                    .into_iter()
5294                    .map(|p| ("id__lte".to_owned(), p.to_string()))
5295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5296            ),
5297            _ => local_var_req_builder.query(&[(
5298                "id__lte",
5299                &local_var_str
5300                    .into_iter()
5301                    .map(|p| p.to_string())
5302                    .collect::<Vec<String>>()
5303                    .join(",")
5304                    .to_string(),
5305            )]),
5306        };
5307    }
5308    if let Some(ref local_var_str) = id__n {
5309        local_var_req_builder = match "multi" {
5310            "multi" => local_var_req_builder.query(
5311                &local_var_str
5312                    .into_iter()
5313                    .map(|p| ("id__n".to_owned(), p.to_string()))
5314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5315            ),
5316            _ => local_var_req_builder.query(&[(
5317                "id__n",
5318                &local_var_str
5319                    .into_iter()
5320                    .map(|p| p.to_string())
5321                    .collect::<Vec<String>>()
5322                    .join(",")
5323                    .to_string(),
5324            )]),
5325        };
5326    }
5327    if let Some(ref local_var_str) = last_updated {
5328        local_var_req_builder = match "multi" {
5329            "multi" => local_var_req_builder.query(
5330                &local_var_str
5331                    .into_iter()
5332                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5334            ),
5335            _ => local_var_req_builder.query(&[(
5336                "last_updated",
5337                &local_var_str
5338                    .into_iter()
5339                    .map(|p| p.to_string())
5340                    .collect::<Vec<String>>()
5341                    .join(",")
5342                    .to_string(),
5343            )]),
5344        };
5345    }
5346    if let Some(ref local_var_str) = last_updated__empty {
5347        local_var_req_builder = match "multi" {
5348            "multi" => local_var_req_builder.query(
5349                &local_var_str
5350                    .into_iter()
5351                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
5352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5353            ),
5354            _ => local_var_req_builder.query(&[(
5355                "last_updated__empty",
5356                &local_var_str
5357                    .into_iter()
5358                    .map(|p| p.to_string())
5359                    .collect::<Vec<String>>()
5360                    .join(",")
5361                    .to_string(),
5362            )]),
5363        };
5364    }
5365    if let Some(ref local_var_str) = last_updated__gt {
5366        local_var_req_builder = match "multi" {
5367            "multi" => local_var_req_builder.query(
5368                &local_var_str
5369                    .into_iter()
5370                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5372            ),
5373            _ => local_var_req_builder.query(&[(
5374                "last_updated__gt",
5375                &local_var_str
5376                    .into_iter()
5377                    .map(|p| p.to_string())
5378                    .collect::<Vec<String>>()
5379                    .join(",")
5380                    .to_string(),
5381            )]),
5382        };
5383    }
5384    if let Some(ref local_var_str) = last_updated__gte {
5385        local_var_req_builder = match "multi" {
5386            "multi" => local_var_req_builder.query(
5387                &local_var_str
5388                    .into_iter()
5389                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5391            ),
5392            _ => local_var_req_builder.query(&[(
5393                "last_updated__gte",
5394                &local_var_str
5395                    .into_iter()
5396                    .map(|p| p.to_string())
5397                    .collect::<Vec<String>>()
5398                    .join(",")
5399                    .to_string(),
5400            )]),
5401        };
5402    }
5403    if let Some(ref local_var_str) = last_updated__lt {
5404        local_var_req_builder = match "multi" {
5405            "multi" => local_var_req_builder.query(
5406                &local_var_str
5407                    .into_iter()
5408                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5410            ),
5411            _ => local_var_req_builder.query(&[(
5412                "last_updated__lt",
5413                &local_var_str
5414                    .into_iter()
5415                    .map(|p| p.to_string())
5416                    .collect::<Vec<String>>()
5417                    .join(",")
5418                    .to_string(),
5419            )]),
5420        };
5421    }
5422    if let Some(ref local_var_str) = last_updated__lte {
5423        local_var_req_builder = match "multi" {
5424            "multi" => local_var_req_builder.query(
5425                &local_var_str
5426                    .into_iter()
5427                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5429            ),
5430            _ => local_var_req_builder.query(&[(
5431                "last_updated__lte",
5432                &local_var_str
5433                    .into_iter()
5434                    .map(|p| p.to_string())
5435                    .collect::<Vec<String>>()
5436                    .join(",")
5437                    .to_string(),
5438            )]),
5439        };
5440    }
5441    if let Some(ref local_var_str) = last_updated__n {
5442        local_var_req_builder = match "multi" {
5443            "multi" => local_var_req_builder.query(
5444                &local_var_str
5445                    .into_iter()
5446                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5448            ),
5449            _ => local_var_req_builder.query(&[(
5450                "last_updated__n",
5451                &local_var_str
5452                    .into_iter()
5453                    .map(|p| p.to_string())
5454                    .collect::<Vec<String>>()
5455                    .join(",")
5456                    .to_string(),
5457            )]),
5458        };
5459    }
5460    if let Some(ref local_var_str) = limit {
5461        local_var_req_builder =
5462            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5463    }
5464    if let Some(ref local_var_str) = location {
5465        local_var_req_builder = match "multi" {
5466            "multi" => local_var_req_builder.query(
5467                &local_var_str
5468                    .into_iter()
5469                    .map(|p| ("location".to_owned(), p.to_string()))
5470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5471            ),
5472            _ => local_var_req_builder.query(&[(
5473                "location",
5474                &local_var_str
5475                    .into_iter()
5476                    .map(|p| p.to_string())
5477                    .collect::<Vec<String>>()
5478                    .join(",")
5479                    .to_string(),
5480            )]),
5481        };
5482    }
5483    if let Some(ref local_var_str) = location__n {
5484        local_var_req_builder = match "multi" {
5485            "multi" => local_var_req_builder.query(
5486                &local_var_str
5487                    .into_iter()
5488                    .map(|p| ("location__n".to_owned(), p.to_string()))
5489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5490            ),
5491            _ => local_var_req_builder.query(&[(
5492                "location__n",
5493                &local_var_str
5494                    .into_iter()
5495                    .map(|p| p.to_string())
5496                    .collect::<Vec<String>>()
5497                    .join(",")
5498                    .to_string(),
5499            )]),
5500        };
5501    }
5502    if let Some(ref local_var_str) = location_id {
5503        local_var_req_builder = match "multi" {
5504            "multi" => local_var_req_builder.query(
5505                &local_var_str
5506                    .into_iter()
5507                    .map(|p| ("location_id".to_owned(), p.to_string()))
5508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5509            ),
5510            _ => local_var_req_builder.query(&[(
5511                "location_id",
5512                &local_var_str
5513                    .into_iter()
5514                    .map(|p| p.to_string())
5515                    .collect::<Vec<String>>()
5516                    .join(",")
5517                    .to_string(),
5518            )]),
5519        };
5520    }
5521    if let Some(ref local_var_str) = location_id__n {
5522        local_var_req_builder = match "multi" {
5523            "multi" => local_var_req_builder.query(
5524                &local_var_str
5525                    .into_iter()
5526                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
5527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5528            ),
5529            _ => local_var_req_builder.query(&[(
5530                "location_id__n",
5531                &local_var_str
5532                    .into_iter()
5533                    .map(|p| p.to_string())
5534                    .collect::<Vec<String>>()
5535                    .join(",")
5536                    .to_string(),
5537            )]),
5538        };
5539    }
5540    if let Some(ref local_var_str) = modified_by_request {
5541        local_var_req_builder =
5542            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5543    }
5544    if let Some(ref local_var_str) = name {
5545        local_var_req_builder = match "multi" {
5546            "multi" => local_var_req_builder.query(
5547                &local_var_str
5548                    .into_iter()
5549                    .map(|p| ("name".to_owned(), p.to_string()))
5550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5551            ),
5552            _ => local_var_req_builder.query(&[(
5553                "name",
5554                &local_var_str
5555                    .into_iter()
5556                    .map(|p| p.to_string())
5557                    .collect::<Vec<String>>()
5558                    .join(",")
5559                    .to_string(),
5560            )]),
5561        };
5562    }
5563    if let Some(ref local_var_str) = name__empty {
5564        local_var_req_builder =
5565            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5566    }
5567    if let Some(ref local_var_str) = name__ic {
5568        local_var_req_builder = match "multi" {
5569            "multi" => local_var_req_builder.query(
5570                &local_var_str
5571                    .into_iter()
5572                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5574            ),
5575            _ => local_var_req_builder.query(&[(
5576                "name__ic",
5577                &local_var_str
5578                    .into_iter()
5579                    .map(|p| p.to_string())
5580                    .collect::<Vec<String>>()
5581                    .join(",")
5582                    .to_string(),
5583            )]),
5584        };
5585    }
5586    if let Some(ref local_var_str) = name__ie {
5587        local_var_req_builder = match "multi" {
5588            "multi" => local_var_req_builder.query(
5589                &local_var_str
5590                    .into_iter()
5591                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5593            ),
5594            _ => local_var_req_builder.query(&[(
5595                "name__ie",
5596                &local_var_str
5597                    .into_iter()
5598                    .map(|p| p.to_string())
5599                    .collect::<Vec<String>>()
5600                    .join(",")
5601                    .to_string(),
5602            )]),
5603        };
5604    }
5605    if let Some(ref local_var_str) = name__iew {
5606        local_var_req_builder = match "multi" {
5607            "multi" => local_var_req_builder.query(
5608                &local_var_str
5609                    .into_iter()
5610                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5612            ),
5613            _ => local_var_req_builder.query(&[(
5614                "name__iew",
5615                &local_var_str
5616                    .into_iter()
5617                    .map(|p| p.to_string())
5618                    .collect::<Vec<String>>()
5619                    .join(",")
5620                    .to_string(),
5621            )]),
5622        };
5623    }
5624    if let Some(ref local_var_str) = name__iregex {
5625        local_var_req_builder = match "multi" {
5626            "multi" => local_var_req_builder.query(
5627                &local_var_str
5628                    .into_iter()
5629                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5631            ),
5632            _ => local_var_req_builder.query(&[(
5633                "name__iregex",
5634                &local_var_str
5635                    .into_iter()
5636                    .map(|p| p.to_string())
5637                    .collect::<Vec<String>>()
5638                    .join(",")
5639                    .to_string(),
5640            )]),
5641        };
5642    }
5643    if let Some(ref local_var_str) = name__isw {
5644        local_var_req_builder = match "multi" {
5645            "multi" => local_var_req_builder.query(
5646                &local_var_str
5647                    .into_iter()
5648                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5650            ),
5651            _ => local_var_req_builder.query(&[(
5652                "name__isw",
5653                &local_var_str
5654                    .into_iter()
5655                    .map(|p| p.to_string())
5656                    .collect::<Vec<String>>()
5657                    .join(",")
5658                    .to_string(),
5659            )]),
5660        };
5661    }
5662    if let Some(ref local_var_str) = name__n {
5663        local_var_req_builder = match "multi" {
5664            "multi" => local_var_req_builder.query(
5665                &local_var_str
5666                    .into_iter()
5667                    .map(|p| ("name__n".to_owned(), p.to_string()))
5668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5669            ),
5670            _ => local_var_req_builder.query(&[(
5671                "name__n",
5672                &local_var_str
5673                    .into_iter()
5674                    .map(|p| p.to_string())
5675                    .collect::<Vec<String>>()
5676                    .join(",")
5677                    .to_string(),
5678            )]),
5679        };
5680    }
5681    if let Some(ref local_var_str) = name__nic {
5682        local_var_req_builder = match "multi" {
5683            "multi" => local_var_req_builder.query(
5684                &local_var_str
5685                    .into_iter()
5686                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5688            ),
5689            _ => local_var_req_builder.query(&[(
5690                "name__nic",
5691                &local_var_str
5692                    .into_iter()
5693                    .map(|p| p.to_string())
5694                    .collect::<Vec<String>>()
5695                    .join(",")
5696                    .to_string(),
5697            )]),
5698        };
5699    }
5700    if let Some(ref local_var_str) = name__nie {
5701        local_var_req_builder = match "multi" {
5702            "multi" => local_var_req_builder.query(
5703                &local_var_str
5704                    .into_iter()
5705                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5707            ),
5708            _ => local_var_req_builder.query(&[(
5709                "name__nie",
5710                &local_var_str
5711                    .into_iter()
5712                    .map(|p| p.to_string())
5713                    .collect::<Vec<String>>()
5714                    .join(",")
5715                    .to_string(),
5716            )]),
5717        };
5718    }
5719    if let Some(ref local_var_str) = name__niew {
5720        local_var_req_builder = match "multi" {
5721            "multi" => local_var_req_builder.query(
5722                &local_var_str
5723                    .into_iter()
5724                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5726            ),
5727            _ => local_var_req_builder.query(&[(
5728                "name__niew",
5729                &local_var_str
5730                    .into_iter()
5731                    .map(|p| p.to_string())
5732                    .collect::<Vec<String>>()
5733                    .join(",")
5734                    .to_string(),
5735            )]),
5736        };
5737    }
5738    if let Some(ref local_var_str) = name__nisw {
5739        local_var_req_builder = match "multi" {
5740            "multi" => local_var_req_builder.query(
5741                &local_var_str
5742                    .into_iter()
5743                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5745            ),
5746            _ => local_var_req_builder.query(&[(
5747                "name__nisw",
5748                &local_var_str
5749                    .into_iter()
5750                    .map(|p| p.to_string())
5751                    .collect::<Vec<String>>()
5752                    .join(",")
5753                    .to_string(),
5754            )]),
5755        };
5756    }
5757    if let Some(ref local_var_str) = name__regex {
5758        local_var_req_builder = match "multi" {
5759            "multi" => local_var_req_builder.query(
5760                &local_var_str
5761                    .into_iter()
5762                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5764            ),
5765            _ => local_var_req_builder.query(&[(
5766                "name__regex",
5767                &local_var_str
5768                    .into_iter()
5769                    .map(|p| p.to_string())
5770                    .collect::<Vec<String>>()
5771                    .join(",")
5772                    .to_string(),
5773            )]),
5774        };
5775    }
5776    if let Some(ref local_var_str) = offset {
5777        local_var_req_builder =
5778            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5779    }
5780    if let Some(ref local_var_str) = ordering {
5781        local_var_req_builder =
5782            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5783    }
5784    if let Some(ref local_var_str) = owner {
5785        local_var_req_builder = match "multi" {
5786            "multi" => local_var_req_builder.query(
5787                &local_var_str
5788                    .into_iter()
5789                    .map(|p| ("owner".to_owned(), p.to_string()))
5790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5791            ),
5792            _ => local_var_req_builder.query(&[(
5793                "owner",
5794                &local_var_str
5795                    .into_iter()
5796                    .map(|p| p.to_string())
5797                    .collect::<Vec<String>>()
5798                    .join(",")
5799                    .to_string(),
5800            )]),
5801        };
5802    }
5803    if let Some(ref local_var_str) = owner__n {
5804        local_var_req_builder = match "multi" {
5805            "multi" => local_var_req_builder.query(
5806                &local_var_str
5807                    .into_iter()
5808                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5810            ),
5811            _ => local_var_req_builder.query(&[(
5812                "owner__n",
5813                &local_var_str
5814                    .into_iter()
5815                    .map(|p| p.to_string())
5816                    .collect::<Vec<String>>()
5817                    .join(",")
5818                    .to_string(),
5819            )]),
5820        };
5821    }
5822    if let Some(ref local_var_str) = owner_group {
5823        local_var_req_builder = match "multi" {
5824            "multi" => local_var_req_builder.query(
5825                &local_var_str
5826                    .into_iter()
5827                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5829            ),
5830            _ => local_var_req_builder.query(&[(
5831                "owner_group",
5832                &local_var_str
5833                    .into_iter()
5834                    .map(|p| p.to_string())
5835                    .collect::<Vec<String>>()
5836                    .join(",")
5837                    .to_string(),
5838            )]),
5839        };
5840    }
5841    if let Some(ref local_var_str) = owner_group__n {
5842        local_var_req_builder = match "multi" {
5843            "multi" => local_var_req_builder.query(
5844                &local_var_str
5845                    .into_iter()
5846                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5848            ),
5849            _ => local_var_req_builder.query(&[(
5850                "owner_group__n",
5851                &local_var_str
5852                    .into_iter()
5853                    .map(|p| p.to_string())
5854                    .collect::<Vec<String>>()
5855                    .join(",")
5856                    .to_string(),
5857            )]),
5858        };
5859    }
5860    if let Some(ref local_var_str) = owner_group_id {
5861        local_var_req_builder = match "multi" {
5862            "multi" => local_var_req_builder.query(
5863                &local_var_str
5864                    .into_iter()
5865                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5867            ),
5868            _ => local_var_req_builder.query(&[(
5869                "owner_group_id",
5870                &local_var_str
5871                    .into_iter()
5872                    .map(|p| p.to_string())
5873                    .collect::<Vec<String>>()
5874                    .join(",")
5875                    .to_string(),
5876            )]),
5877        };
5878    }
5879    if let Some(ref local_var_str) = owner_group_id__n {
5880        local_var_req_builder = match "multi" {
5881            "multi" => local_var_req_builder.query(
5882                &local_var_str
5883                    .into_iter()
5884                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5886            ),
5887            _ => local_var_req_builder.query(&[(
5888                "owner_group_id__n",
5889                &local_var_str
5890                    .into_iter()
5891                    .map(|p| p.to_string())
5892                    .collect::<Vec<String>>()
5893                    .join(",")
5894                    .to_string(),
5895            )]),
5896        };
5897    }
5898    if let Some(ref local_var_str) = owner_id {
5899        local_var_req_builder = match "multi" {
5900            "multi" => local_var_req_builder.query(
5901                &local_var_str
5902                    .into_iter()
5903                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5905            ),
5906            _ => local_var_req_builder.query(&[(
5907                "owner_id",
5908                &local_var_str
5909                    .into_iter()
5910                    .map(|p| p.to_string())
5911                    .collect::<Vec<String>>()
5912                    .join(",")
5913                    .to_string(),
5914            )]),
5915        };
5916    }
5917    if let Some(ref local_var_str) = owner_id__n {
5918        local_var_req_builder = match "multi" {
5919            "multi" => local_var_req_builder.query(
5920                &local_var_str
5921                    .into_iter()
5922                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5924            ),
5925            _ => local_var_req_builder.query(&[(
5926                "owner_id__n",
5927                &local_var_str
5928                    .into_iter()
5929                    .map(|p| p.to_string())
5930                    .collect::<Vec<String>>()
5931                    .join(",")
5932                    .to_string(),
5933            )]),
5934        };
5935    }
5936    if let Some(ref local_var_str) = q {
5937        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5938    }
5939    if let Some(ref local_var_str) = region {
5940        local_var_req_builder = match "multi" {
5941            "multi" => local_var_req_builder.query(
5942                &local_var_str
5943                    .into_iter()
5944                    .map(|p| ("region".to_owned(), p.to_string()))
5945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5946            ),
5947            _ => local_var_req_builder.query(&[(
5948                "region",
5949                &local_var_str
5950                    .into_iter()
5951                    .map(|p| p.to_string())
5952                    .collect::<Vec<String>>()
5953                    .join(",")
5954                    .to_string(),
5955            )]),
5956        };
5957    }
5958    if let Some(ref local_var_str) = region__n {
5959        local_var_req_builder = match "multi" {
5960            "multi" => local_var_req_builder.query(
5961                &local_var_str
5962                    .into_iter()
5963                    .map(|p| ("region__n".to_owned(), p.to_string()))
5964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5965            ),
5966            _ => local_var_req_builder.query(&[(
5967                "region__n",
5968                &local_var_str
5969                    .into_iter()
5970                    .map(|p| p.to_string())
5971                    .collect::<Vec<String>>()
5972                    .join(",")
5973                    .to_string(),
5974            )]),
5975        };
5976    }
5977    if let Some(ref local_var_str) = region_id {
5978        local_var_req_builder = match "multi" {
5979            "multi" => local_var_req_builder.query(
5980                &local_var_str
5981                    .into_iter()
5982                    .map(|p| ("region_id".to_owned(), p.to_string()))
5983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5984            ),
5985            _ => local_var_req_builder.query(&[(
5986                "region_id",
5987                &local_var_str
5988                    .into_iter()
5989                    .map(|p| p.to_string())
5990                    .collect::<Vec<String>>()
5991                    .join(",")
5992                    .to_string(),
5993            )]),
5994        };
5995    }
5996    if let Some(ref local_var_str) = region_id__n {
5997        local_var_req_builder = match "multi" {
5998            "multi" => local_var_req_builder.query(
5999                &local_var_str
6000                    .into_iter()
6001                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
6002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6003            ),
6004            _ => local_var_req_builder.query(&[(
6005                "region_id__n",
6006                &local_var_str
6007                    .into_iter()
6008                    .map(|p| p.to_string())
6009                    .collect::<Vec<String>>()
6010                    .join(",")
6011                    .to_string(),
6012            )]),
6013        };
6014    }
6015    if let Some(ref local_var_str) = scope_id {
6016        local_var_req_builder = match "multi" {
6017            "multi" => local_var_req_builder.query(
6018                &local_var_str
6019                    .into_iter()
6020                    .map(|p| ("scope_id".to_owned(), p.to_string()))
6021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6022            ),
6023            _ => local_var_req_builder.query(&[(
6024                "scope_id",
6025                &local_var_str
6026                    .into_iter()
6027                    .map(|p| p.to_string())
6028                    .collect::<Vec<String>>()
6029                    .join(",")
6030                    .to_string(),
6031            )]),
6032        };
6033    }
6034    if let Some(ref local_var_str) = scope_id__empty {
6035        local_var_req_builder =
6036            local_var_req_builder.query(&[("scope_id__empty", &local_var_str.to_string())]);
6037    }
6038    if let Some(ref local_var_str) = scope_id__gt {
6039        local_var_req_builder = match "multi" {
6040            "multi" => local_var_req_builder.query(
6041                &local_var_str
6042                    .into_iter()
6043                    .map(|p| ("scope_id__gt".to_owned(), p.to_string()))
6044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6045            ),
6046            _ => local_var_req_builder.query(&[(
6047                "scope_id__gt",
6048                &local_var_str
6049                    .into_iter()
6050                    .map(|p| p.to_string())
6051                    .collect::<Vec<String>>()
6052                    .join(",")
6053                    .to_string(),
6054            )]),
6055        };
6056    }
6057    if let Some(ref local_var_str) = scope_id__gte {
6058        local_var_req_builder = match "multi" {
6059            "multi" => local_var_req_builder.query(
6060                &local_var_str
6061                    .into_iter()
6062                    .map(|p| ("scope_id__gte".to_owned(), p.to_string()))
6063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6064            ),
6065            _ => local_var_req_builder.query(&[(
6066                "scope_id__gte",
6067                &local_var_str
6068                    .into_iter()
6069                    .map(|p| p.to_string())
6070                    .collect::<Vec<String>>()
6071                    .join(",")
6072                    .to_string(),
6073            )]),
6074        };
6075    }
6076    if let Some(ref local_var_str) = scope_id__lt {
6077        local_var_req_builder = match "multi" {
6078            "multi" => local_var_req_builder.query(
6079                &local_var_str
6080                    .into_iter()
6081                    .map(|p| ("scope_id__lt".to_owned(), p.to_string()))
6082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6083            ),
6084            _ => local_var_req_builder.query(&[(
6085                "scope_id__lt",
6086                &local_var_str
6087                    .into_iter()
6088                    .map(|p| p.to_string())
6089                    .collect::<Vec<String>>()
6090                    .join(",")
6091                    .to_string(),
6092            )]),
6093        };
6094    }
6095    if let Some(ref local_var_str) = scope_id__lte {
6096        local_var_req_builder = match "multi" {
6097            "multi" => local_var_req_builder.query(
6098                &local_var_str
6099                    .into_iter()
6100                    .map(|p| ("scope_id__lte".to_owned(), p.to_string()))
6101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6102            ),
6103            _ => local_var_req_builder.query(&[(
6104                "scope_id__lte",
6105                &local_var_str
6106                    .into_iter()
6107                    .map(|p| p.to_string())
6108                    .collect::<Vec<String>>()
6109                    .join(",")
6110                    .to_string(),
6111            )]),
6112        };
6113    }
6114    if let Some(ref local_var_str) = scope_id__n {
6115        local_var_req_builder = match "multi" {
6116            "multi" => local_var_req_builder.query(
6117                &local_var_str
6118                    .into_iter()
6119                    .map(|p| ("scope_id__n".to_owned(), p.to_string()))
6120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6121            ),
6122            _ => local_var_req_builder.query(&[(
6123                "scope_id__n",
6124                &local_var_str
6125                    .into_iter()
6126                    .map(|p| p.to_string())
6127                    .collect::<Vec<String>>()
6128                    .join(",")
6129                    .to_string(),
6130            )]),
6131        };
6132    }
6133    if let Some(ref local_var_str) = scope_type {
6134        local_var_req_builder = match "multi" {
6135            "multi" => local_var_req_builder.query(
6136                &local_var_str
6137                    .into_iter()
6138                    .map(|p| ("scope_type".to_owned(), p.to_string()))
6139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6140            ),
6141            _ => local_var_req_builder.query(&[(
6142                "scope_type",
6143                &local_var_str
6144                    .into_iter()
6145                    .map(|p| p.to_string())
6146                    .collect::<Vec<String>>()
6147                    .join(",")
6148                    .to_string(),
6149            )]),
6150        };
6151    }
6152    if let Some(ref local_var_str) = scope_type__n {
6153        local_var_req_builder = match "multi" {
6154            "multi" => local_var_req_builder.query(
6155                &local_var_str
6156                    .into_iter()
6157                    .map(|p| ("scope_type__n".to_owned(), p.to_string()))
6158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6159            ),
6160            _ => local_var_req_builder.query(&[(
6161                "scope_type__n",
6162                &local_var_str
6163                    .into_iter()
6164                    .map(|p| p.to_string())
6165                    .collect::<Vec<String>>()
6166                    .join(",")
6167                    .to_string(),
6168            )]),
6169        };
6170    }
6171    if let Some(ref local_var_str) = site {
6172        local_var_req_builder = match "multi" {
6173            "multi" => local_var_req_builder.query(
6174                &local_var_str
6175                    .into_iter()
6176                    .map(|p| ("site".to_owned(), p.to_string()))
6177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6178            ),
6179            _ => local_var_req_builder.query(&[(
6180                "site",
6181                &local_var_str
6182                    .into_iter()
6183                    .map(|p| p.to_string())
6184                    .collect::<Vec<String>>()
6185                    .join(",")
6186                    .to_string(),
6187            )]),
6188        };
6189    }
6190    if let Some(ref local_var_str) = site__n {
6191        local_var_req_builder = match "multi" {
6192            "multi" => local_var_req_builder.query(
6193                &local_var_str
6194                    .into_iter()
6195                    .map(|p| ("site__n".to_owned(), p.to_string()))
6196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6197            ),
6198            _ => local_var_req_builder.query(&[(
6199                "site__n",
6200                &local_var_str
6201                    .into_iter()
6202                    .map(|p| p.to_string())
6203                    .collect::<Vec<String>>()
6204                    .join(",")
6205                    .to_string(),
6206            )]),
6207        };
6208    }
6209    if let Some(ref local_var_str) = site_group {
6210        local_var_req_builder = match "multi" {
6211            "multi" => local_var_req_builder.query(
6212                &local_var_str
6213                    .into_iter()
6214                    .map(|p| ("site_group".to_owned(), p.to_string()))
6215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6216            ),
6217            _ => local_var_req_builder.query(&[(
6218                "site_group",
6219                &local_var_str
6220                    .into_iter()
6221                    .map(|p| p.to_string())
6222                    .collect::<Vec<String>>()
6223                    .join(",")
6224                    .to_string(),
6225            )]),
6226        };
6227    }
6228    if let Some(ref local_var_str) = site_group__n {
6229        local_var_req_builder = match "multi" {
6230            "multi" => local_var_req_builder.query(
6231                &local_var_str
6232                    .into_iter()
6233                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
6234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6235            ),
6236            _ => local_var_req_builder.query(&[(
6237                "site_group__n",
6238                &local_var_str
6239                    .into_iter()
6240                    .map(|p| p.to_string())
6241                    .collect::<Vec<String>>()
6242                    .join(",")
6243                    .to_string(),
6244            )]),
6245        };
6246    }
6247    if let Some(ref local_var_str) = site_group_id {
6248        local_var_req_builder = match "multi" {
6249            "multi" => local_var_req_builder.query(
6250                &local_var_str
6251                    .into_iter()
6252                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
6253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6254            ),
6255            _ => local_var_req_builder.query(&[(
6256                "site_group_id",
6257                &local_var_str
6258                    .into_iter()
6259                    .map(|p| p.to_string())
6260                    .collect::<Vec<String>>()
6261                    .join(",")
6262                    .to_string(),
6263            )]),
6264        };
6265    }
6266    if let Some(ref local_var_str) = site_group_id__n {
6267        local_var_req_builder = match "multi" {
6268            "multi" => local_var_req_builder.query(
6269                &local_var_str
6270                    .into_iter()
6271                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
6272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6273            ),
6274            _ => local_var_req_builder.query(&[(
6275                "site_group_id__n",
6276                &local_var_str
6277                    .into_iter()
6278                    .map(|p| p.to_string())
6279                    .collect::<Vec<String>>()
6280                    .join(",")
6281                    .to_string(),
6282            )]),
6283        };
6284    }
6285    if let Some(ref local_var_str) = site_id {
6286        local_var_req_builder = match "multi" {
6287            "multi" => local_var_req_builder.query(
6288                &local_var_str
6289                    .into_iter()
6290                    .map(|p| ("site_id".to_owned(), p.to_string()))
6291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6292            ),
6293            _ => local_var_req_builder.query(&[(
6294                "site_id",
6295                &local_var_str
6296                    .into_iter()
6297                    .map(|p| p.to_string())
6298                    .collect::<Vec<String>>()
6299                    .join(",")
6300                    .to_string(),
6301            )]),
6302        };
6303    }
6304    if let Some(ref local_var_str) = site_id__n {
6305        local_var_req_builder = match "multi" {
6306            "multi" => local_var_req_builder.query(
6307                &local_var_str
6308                    .into_iter()
6309                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
6310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6311            ),
6312            _ => local_var_req_builder.query(&[(
6313                "site_id__n",
6314                &local_var_str
6315                    .into_iter()
6316                    .map(|p| p.to_string())
6317                    .collect::<Vec<String>>()
6318                    .join(",")
6319                    .to_string(),
6320            )]),
6321        };
6322    }
6323    if let Some(ref local_var_str) = status {
6324        local_var_req_builder = match "multi" {
6325            "multi" => local_var_req_builder.query(
6326                &local_var_str
6327                    .into_iter()
6328                    .map(|p| ("status".to_owned(), p.to_string()))
6329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6330            ),
6331            _ => local_var_req_builder.query(&[(
6332                "status",
6333                &local_var_str
6334                    .into_iter()
6335                    .map(|p| p.to_string())
6336                    .collect::<Vec<String>>()
6337                    .join(",")
6338                    .to_string(),
6339            )]),
6340        };
6341    }
6342    if let Some(ref local_var_str) = status__empty {
6343        local_var_req_builder =
6344            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
6345    }
6346    if let Some(ref local_var_str) = status__ic {
6347        local_var_req_builder = match "multi" {
6348            "multi" => local_var_req_builder.query(
6349                &local_var_str
6350                    .into_iter()
6351                    .map(|p| ("status__ic".to_owned(), p.to_string()))
6352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6353            ),
6354            _ => local_var_req_builder.query(&[(
6355                "status__ic",
6356                &local_var_str
6357                    .into_iter()
6358                    .map(|p| p.to_string())
6359                    .collect::<Vec<String>>()
6360                    .join(",")
6361                    .to_string(),
6362            )]),
6363        };
6364    }
6365    if let Some(ref local_var_str) = status__ie {
6366        local_var_req_builder = match "multi" {
6367            "multi" => local_var_req_builder.query(
6368                &local_var_str
6369                    .into_iter()
6370                    .map(|p| ("status__ie".to_owned(), p.to_string()))
6371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6372            ),
6373            _ => local_var_req_builder.query(&[(
6374                "status__ie",
6375                &local_var_str
6376                    .into_iter()
6377                    .map(|p| p.to_string())
6378                    .collect::<Vec<String>>()
6379                    .join(",")
6380                    .to_string(),
6381            )]),
6382        };
6383    }
6384    if let Some(ref local_var_str) = status__iew {
6385        local_var_req_builder = match "multi" {
6386            "multi" => local_var_req_builder.query(
6387                &local_var_str
6388                    .into_iter()
6389                    .map(|p| ("status__iew".to_owned(), p.to_string()))
6390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6391            ),
6392            _ => local_var_req_builder.query(&[(
6393                "status__iew",
6394                &local_var_str
6395                    .into_iter()
6396                    .map(|p| p.to_string())
6397                    .collect::<Vec<String>>()
6398                    .join(",")
6399                    .to_string(),
6400            )]),
6401        };
6402    }
6403    if let Some(ref local_var_str) = status__iregex {
6404        local_var_req_builder = match "multi" {
6405            "multi" => local_var_req_builder.query(
6406                &local_var_str
6407                    .into_iter()
6408                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
6409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6410            ),
6411            _ => local_var_req_builder.query(&[(
6412                "status__iregex",
6413                &local_var_str
6414                    .into_iter()
6415                    .map(|p| p.to_string())
6416                    .collect::<Vec<String>>()
6417                    .join(",")
6418                    .to_string(),
6419            )]),
6420        };
6421    }
6422    if let Some(ref local_var_str) = status__isw {
6423        local_var_req_builder = match "multi" {
6424            "multi" => local_var_req_builder.query(
6425                &local_var_str
6426                    .into_iter()
6427                    .map(|p| ("status__isw".to_owned(), p.to_string()))
6428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6429            ),
6430            _ => local_var_req_builder.query(&[(
6431                "status__isw",
6432                &local_var_str
6433                    .into_iter()
6434                    .map(|p| p.to_string())
6435                    .collect::<Vec<String>>()
6436                    .join(",")
6437                    .to_string(),
6438            )]),
6439        };
6440    }
6441    if let Some(ref local_var_str) = status__n {
6442        local_var_req_builder = match "multi" {
6443            "multi" => local_var_req_builder.query(
6444                &local_var_str
6445                    .into_iter()
6446                    .map(|p| ("status__n".to_owned(), p.to_string()))
6447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6448            ),
6449            _ => local_var_req_builder.query(&[(
6450                "status__n",
6451                &local_var_str
6452                    .into_iter()
6453                    .map(|p| p.to_string())
6454                    .collect::<Vec<String>>()
6455                    .join(",")
6456                    .to_string(),
6457            )]),
6458        };
6459    }
6460    if let Some(ref local_var_str) = status__nic {
6461        local_var_req_builder = match "multi" {
6462            "multi" => local_var_req_builder.query(
6463                &local_var_str
6464                    .into_iter()
6465                    .map(|p| ("status__nic".to_owned(), p.to_string()))
6466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6467            ),
6468            _ => local_var_req_builder.query(&[(
6469                "status__nic",
6470                &local_var_str
6471                    .into_iter()
6472                    .map(|p| p.to_string())
6473                    .collect::<Vec<String>>()
6474                    .join(",")
6475                    .to_string(),
6476            )]),
6477        };
6478    }
6479    if let Some(ref local_var_str) = status__nie {
6480        local_var_req_builder = match "multi" {
6481            "multi" => local_var_req_builder.query(
6482                &local_var_str
6483                    .into_iter()
6484                    .map(|p| ("status__nie".to_owned(), p.to_string()))
6485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6486            ),
6487            _ => local_var_req_builder.query(&[(
6488                "status__nie",
6489                &local_var_str
6490                    .into_iter()
6491                    .map(|p| p.to_string())
6492                    .collect::<Vec<String>>()
6493                    .join(",")
6494                    .to_string(),
6495            )]),
6496        };
6497    }
6498    if let Some(ref local_var_str) = status__niew {
6499        local_var_req_builder = match "multi" {
6500            "multi" => local_var_req_builder.query(
6501                &local_var_str
6502                    .into_iter()
6503                    .map(|p| ("status__niew".to_owned(), p.to_string()))
6504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6505            ),
6506            _ => local_var_req_builder.query(&[(
6507                "status__niew",
6508                &local_var_str
6509                    .into_iter()
6510                    .map(|p| p.to_string())
6511                    .collect::<Vec<String>>()
6512                    .join(",")
6513                    .to_string(),
6514            )]),
6515        };
6516    }
6517    if let Some(ref local_var_str) = status__nisw {
6518        local_var_req_builder = match "multi" {
6519            "multi" => local_var_req_builder.query(
6520                &local_var_str
6521                    .into_iter()
6522                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
6523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6524            ),
6525            _ => local_var_req_builder.query(&[(
6526                "status__nisw",
6527                &local_var_str
6528                    .into_iter()
6529                    .map(|p| p.to_string())
6530                    .collect::<Vec<String>>()
6531                    .join(",")
6532                    .to_string(),
6533            )]),
6534        };
6535    }
6536    if let Some(ref local_var_str) = status__regex {
6537        local_var_req_builder = match "multi" {
6538            "multi" => local_var_req_builder.query(
6539                &local_var_str
6540                    .into_iter()
6541                    .map(|p| ("status__regex".to_owned(), p.to_string()))
6542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6543            ),
6544            _ => local_var_req_builder.query(&[(
6545                "status__regex",
6546                &local_var_str
6547                    .into_iter()
6548                    .map(|p| p.to_string())
6549                    .collect::<Vec<String>>()
6550                    .join(",")
6551                    .to_string(),
6552            )]),
6553        };
6554    }
6555    if let Some(ref local_var_str) = tag {
6556        local_var_req_builder = match "multi" {
6557            "multi" => local_var_req_builder.query(
6558                &local_var_str
6559                    .into_iter()
6560                    .map(|p| ("tag".to_owned(), p.to_string()))
6561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6562            ),
6563            _ => local_var_req_builder.query(&[(
6564                "tag",
6565                &local_var_str
6566                    .into_iter()
6567                    .map(|p| p.to_string())
6568                    .collect::<Vec<String>>()
6569                    .join(",")
6570                    .to_string(),
6571            )]),
6572        };
6573    }
6574    if let Some(ref local_var_str) = tag__n {
6575        local_var_req_builder = match "multi" {
6576            "multi" => local_var_req_builder.query(
6577                &local_var_str
6578                    .into_iter()
6579                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6581            ),
6582            _ => local_var_req_builder.query(&[(
6583                "tag__n",
6584                &local_var_str
6585                    .into_iter()
6586                    .map(|p| p.to_string())
6587                    .collect::<Vec<String>>()
6588                    .join(",")
6589                    .to_string(),
6590            )]),
6591        };
6592    }
6593    if let Some(ref local_var_str) = tag_id {
6594        local_var_req_builder = match "multi" {
6595            "multi" => local_var_req_builder.query(
6596                &local_var_str
6597                    .into_iter()
6598                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6600            ),
6601            _ => local_var_req_builder.query(&[(
6602                "tag_id",
6603                &local_var_str
6604                    .into_iter()
6605                    .map(|p| p.to_string())
6606                    .collect::<Vec<String>>()
6607                    .join(",")
6608                    .to_string(),
6609            )]),
6610        };
6611    }
6612    if let Some(ref local_var_str) = tag_id__n {
6613        local_var_req_builder = match "multi" {
6614            "multi" => local_var_req_builder.query(
6615                &local_var_str
6616                    .into_iter()
6617                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6619            ),
6620            _ => local_var_req_builder.query(&[(
6621                "tag_id__n",
6622                &local_var_str
6623                    .into_iter()
6624                    .map(|p| p.to_string())
6625                    .collect::<Vec<String>>()
6626                    .join(",")
6627                    .to_string(),
6628            )]),
6629        };
6630    }
6631    if let Some(ref local_var_str) = tenant {
6632        local_var_req_builder = match "multi" {
6633            "multi" => local_var_req_builder.query(
6634                &local_var_str
6635                    .into_iter()
6636                    .map(|p| ("tenant".to_owned(), p.to_string()))
6637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6638            ),
6639            _ => local_var_req_builder.query(&[(
6640                "tenant",
6641                &local_var_str
6642                    .into_iter()
6643                    .map(|p| p.to_string())
6644                    .collect::<Vec<String>>()
6645                    .join(",")
6646                    .to_string(),
6647            )]),
6648        };
6649    }
6650    if let Some(ref local_var_str) = tenant__n {
6651        local_var_req_builder = match "multi" {
6652            "multi" => local_var_req_builder.query(
6653                &local_var_str
6654                    .into_iter()
6655                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
6656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6657            ),
6658            _ => local_var_req_builder.query(&[(
6659                "tenant__n",
6660                &local_var_str
6661                    .into_iter()
6662                    .map(|p| p.to_string())
6663                    .collect::<Vec<String>>()
6664                    .join(",")
6665                    .to_string(),
6666            )]),
6667        };
6668    }
6669    if let Some(ref local_var_str) = tenant_group {
6670        local_var_req_builder = match "multi" {
6671            "multi" => local_var_req_builder.query(
6672                &local_var_str
6673                    .into_iter()
6674                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
6675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6676            ),
6677            _ => local_var_req_builder.query(&[(
6678                "tenant_group",
6679                &local_var_str
6680                    .into_iter()
6681                    .map(|p| p.to_string())
6682                    .collect::<Vec<String>>()
6683                    .join(",")
6684                    .to_string(),
6685            )]),
6686        };
6687    }
6688    if let Some(ref local_var_str) = tenant_group__n {
6689        local_var_req_builder = match "multi" {
6690            "multi" => local_var_req_builder.query(
6691                &local_var_str
6692                    .into_iter()
6693                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
6694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6695            ),
6696            _ => local_var_req_builder.query(&[(
6697                "tenant_group__n",
6698                &local_var_str
6699                    .into_iter()
6700                    .map(|p| p.to_string())
6701                    .collect::<Vec<String>>()
6702                    .join(",")
6703                    .to_string(),
6704            )]),
6705        };
6706    }
6707    if let Some(ref local_var_str) = tenant_group_id {
6708        local_var_req_builder = match "multi" {
6709            "multi" => local_var_req_builder.query(
6710                &local_var_str
6711                    .into_iter()
6712                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
6713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6714            ),
6715            _ => local_var_req_builder.query(&[(
6716                "tenant_group_id",
6717                &local_var_str
6718                    .into_iter()
6719                    .map(|p| p.to_string())
6720                    .collect::<Vec<String>>()
6721                    .join(",")
6722                    .to_string(),
6723            )]),
6724        };
6725    }
6726    if let Some(ref local_var_str) = tenant_group_id__n {
6727        local_var_req_builder = match "multi" {
6728            "multi" => local_var_req_builder.query(
6729                &local_var_str
6730                    .into_iter()
6731                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
6732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6733            ),
6734            _ => local_var_req_builder.query(&[(
6735                "tenant_group_id__n",
6736                &local_var_str
6737                    .into_iter()
6738                    .map(|p| p.to_string())
6739                    .collect::<Vec<String>>()
6740                    .join(",")
6741                    .to_string(),
6742            )]),
6743        };
6744    }
6745    if let Some(ref local_var_str) = tenant_id {
6746        local_var_req_builder = match "multi" {
6747            "multi" => local_var_req_builder.query(
6748                &local_var_str
6749                    .into_iter()
6750                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
6751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6752            ),
6753            _ => local_var_req_builder.query(&[(
6754                "tenant_id",
6755                &local_var_str
6756                    .into_iter()
6757                    .map(|p| p.to_string())
6758                    .collect::<Vec<String>>()
6759                    .join(",")
6760                    .to_string(),
6761            )]),
6762        };
6763    }
6764    if let Some(ref local_var_str) = tenant_id__n {
6765        local_var_req_builder = match "multi" {
6766            "multi" => local_var_req_builder.query(
6767                &local_var_str
6768                    .into_iter()
6769                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
6770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6771            ),
6772            _ => local_var_req_builder.query(&[(
6773                "tenant_id__n",
6774                &local_var_str
6775                    .into_iter()
6776                    .map(|p| p.to_string())
6777                    .collect::<Vec<String>>()
6778                    .join(",")
6779                    .to_string(),
6780            )]),
6781        };
6782    }
6783    if let Some(ref local_var_str) = r#type {
6784        local_var_req_builder = match "multi" {
6785            "multi" => local_var_req_builder.query(
6786                &local_var_str
6787                    .into_iter()
6788                    .map(|p| ("type".to_owned(), p.to_string()))
6789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6790            ),
6791            _ => local_var_req_builder.query(&[(
6792                "type",
6793                &local_var_str
6794                    .into_iter()
6795                    .map(|p| p.to_string())
6796                    .collect::<Vec<String>>()
6797                    .join(",")
6798                    .to_string(),
6799            )]),
6800        };
6801    }
6802    if let Some(ref local_var_str) = type__n {
6803        local_var_req_builder = match "multi" {
6804            "multi" => local_var_req_builder.query(
6805                &local_var_str
6806                    .into_iter()
6807                    .map(|p| ("type__n".to_owned(), p.to_string()))
6808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6809            ),
6810            _ => local_var_req_builder.query(&[(
6811                "type__n",
6812                &local_var_str
6813                    .into_iter()
6814                    .map(|p| p.to_string())
6815                    .collect::<Vec<String>>()
6816                    .join(",")
6817                    .to_string(),
6818            )]),
6819        };
6820    }
6821    if let Some(ref local_var_str) = type_id {
6822        local_var_req_builder = match "multi" {
6823            "multi" => local_var_req_builder.query(
6824                &local_var_str
6825                    .into_iter()
6826                    .map(|p| ("type_id".to_owned(), p.to_string()))
6827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6828            ),
6829            _ => local_var_req_builder.query(&[(
6830                "type_id",
6831                &local_var_str
6832                    .into_iter()
6833                    .map(|p| p.to_string())
6834                    .collect::<Vec<String>>()
6835                    .join(",")
6836                    .to_string(),
6837            )]),
6838        };
6839    }
6840    if let Some(ref local_var_str) = type_id__n {
6841        local_var_req_builder = match "multi" {
6842            "multi" => local_var_req_builder.query(
6843                &local_var_str
6844                    .into_iter()
6845                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
6846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6847            ),
6848            _ => local_var_req_builder.query(&[(
6849                "type_id__n",
6850                &local_var_str
6851                    .into_iter()
6852                    .map(|p| p.to_string())
6853                    .collect::<Vec<String>>()
6854                    .join(",")
6855                    .to_string(),
6856            )]),
6857        };
6858    }
6859    if let Some(ref local_var_str) = updated_by_request {
6860        local_var_req_builder =
6861            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
6862    }
6863    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6864        local_var_req_builder =
6865            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6866    }
6867    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6868        let local_var_key = local_var_apikey.key.clone();
6869        let local_var_value = match local_var_apikey.prefix {
6870            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6871            None => local_var_key,
6872        };
6873        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6874    };
6875
6876    let local_var_req = local_var_req_builder.build()?;
6877    let local_var_resp = local_var_client.execute(local_var_req).await?;
6878
6879    let local_var_status = local_var_resp.status();
6880    let local_var_content = local_var_resp.text().await?;
6881
6882    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6883        serde_json::from_str(&local_var_content).map_err(Error::from)
6884    } else {
6885        let local_var_entity: Option<VirtualizationClustersListError> =
6886            serde_json::from_str(&local_var_content).ok();
6887        let local_var_error = ResponseContent {
6888            status: local_var_status,
6889            content: local_var_content,
6890            entity: local_var_entity,
6891        };
6892        Err(Error::ResponseError(local_var_error))
6893    }
6894}
6895
6896/// Patch a cluster object.
6897pub async fn virtualization_clusters_partial_update(
6898    configuration: &configuration::Configuration,
6899    id: i32,
6900    patched_writable_cluster_request: Option<crate::models::PatchedWritableClusterRequest>,
6901) -> Result<crate::models::Cluster, Error<VirtualizationClustersPartialUpdateError>> {
6902    let local_var_configuration = configuration;
6903
6904    let local_var_client = &local_var_configuration.client;
6905
6906    let local_var_uri_str = format!(
6907        "{}/api/virtualization/clusters/{id}/",
6908        local_var_configuration.base_path,
6909        id = id
6910    );
6911    let mut local_var_req_builder =
6912        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6913
6914    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6915        local_var_req_builder =
6916            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6917    }
6918    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6919        let local_var_key = local_var_apikey.key.clone();
6920        let local_var_value = match local_var_apikey.prefix {
6921            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6922            None => local_var_key,
6923        };
6924        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6925    };
6926    local_var_req_builder = local_var_req_builder.json(&patched_writable_cluster_request);
6927
6928    let local_var_req = local_var_req_builder.build()?;
6929    let local_var_resp = local_var_client.execute(local_var_req).await?;
6930
6931    let local_var_status = local_var_resp.status();
6932    let local_var_content = local_var_resp.text().await?;
6933
6934    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6935        serde_json::from_str(&local_var_content).map_err(Error::from)
6936    } else {
6937        let local_var_entity: Option<VirtualizationClustersPartialUpdateError> =
6938            serde_json::from_str(&local_var_content).ok();
6939        let local_var_error = ResponseContent {
6940            status: local_var_status,
6941            content: local_var_content,
6942            entity: local_var_entity,
6943        };
6944        Err(Error::ResponseError(local_var_error))
6945    }
6946}
6947
6948/// Get a cluster object.
6949pub async fn virtualization_clusters_retrieve(
6950    configuration: &configuration::Configuration,
6951    id: i32,
6952) -> Result<crate::models::Cluster, Error<VirtualizationClustersRetrieveError>> {
6953    let local_var_configuration = configuration;
6954
6955    let local_var_client = &local_var_configuration.client;
6956
6957    let local_var_uri_str = format!(
6958        "{}/api/virtualization/clusters/{id}/",
6959        local_var_configuration.base_path,
6960        id = id
6961    );
6962    let mut local_var_req_builder =
6963        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6964
6965    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6966        local_var_req_builder =
6967            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6968    }
6969    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6970        let local_var_key = local_var_apikey.key.clone();
6971        let local_var_value = match local_var_apikey.prefix {
6972            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6973            None => local_var_key,
6974        };
6975        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6976    };
6977
6978    let local_var_req = local_var_req_builder.build()?;
6979    let local_var_resp = local_var_client.execute(local_var_req).await?;
6980
6981    let local_var_status = local_var_resp.status();
6982    let local_var_content = local_var_resp.text().await?;
6983
6984    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6985        serde_json::from_str(&local_var_content).map_err(Error::from)
6986    } else {
6987        let local_var_entity: Option<VirtualizationClustersRetrieveError> =
6988            serde_json::from_str(&local_var_content).ok();
6989        let local_var_error = ResponseContent {
6990            status: local_var_status,
6991            content: local_var_content,
6992            entity: local_var_entity,
6993        };
6994        Err(Error::ResponseError(local_var_error))
6995    }
6996}
6997
6998/// Put a cluster object.
6999pub async fn virtualization_clusters_update(
7000    configuration: &configuration::Configuration,
7001    id: i32,
7002    writable_cluster_request: crate::models::WritableClusterRequest,
7003) -> Result<crate::models::Cluster, Error<VirtualizationClustersUpdateError>> {
7004    let local_var_configuration = configuration;
7005
7006    let local_var_client = &local_var_configuration.client;
7007
7008    let local_var_uri_str = format!(
7009        "{}/api/virtualization/clusters/{id}/",
7010        local_var_configuration.base_path,
7011        id = id
7012    );
7013    let mut local_var_req_builder =
7014        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7015
7016    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7017        local_var_req_builder =
7018            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7019    }
7020    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7021        let local_var_key = local_var_apikey.key.clone();
7022        let local_var_value = match local_var_apikey.prefix {
7023            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7024            None => local_var_key,
7025        };
7026        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7027    };
7028    local_var_req_builder = local_var_req_builder.json(&writable_cluster_request);
7029
7030    let local_var_req = local_var_req_builder.build()?;
7031    let local_var_resp = local_var_client.execute(local_var_req).await?;
7032
7033    let local_var_status = local_var_resp.status();
7034    let local_var_content = local_var_resp.text().await?;
7035
7036    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7037        serde_json::from_str(&local_var_content).map_err(Error::from)
7038    } else {
7039        let local_var_entity: Option<VirtualizationClustersUpdateError> =
7040            serde_json::from_str(&local_var_content).ok();
7041        let local_var_error = ResponseContent {
7042            status: local_var_status,
7043            content: local_var_content,
7044            entity: local_var_entity,
7045        };
7046        Err(Error::ResponseError(local_var_error))
7047    }
7048}
7049
7050/// Delete a list of interface objects.
7051pub async fn virtualization_interfaces_bulk_destroy(
7052    configuration: &configuration::Configuration,
7053    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7054) -> Result<(), Error<VirtualizationInterfacesBulkDestroyError>> {
7055    let local_var_configuration = configuration;
7056
7057    let local_var_client = &local_var_configuration.client;
7058
7059    let local_var_uri_str = format!(
7060        "{}/api/virtualization/interfaces/",
7061        local_var_configuration.base_path
7062    );
7063    let mut local_var_req_builder =
7064        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7065
7066    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7067        local_var_req_builder =
7068            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7069    }
7070    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7071        let local_var_key = local_var_apikey.key.clone();
7072        let local_var_value = match local_var_apikey.prefix {
7073            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7074            None => local_var_key,
7075        };
7076        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7077    };
7078    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7079
7080    let local_var_req = local_var_req_builder.build()?;
7081    let local_var_resp = local_var_client.execute(local_var_req).await?;
7082
7083    let local_var_status = local_var_resp.status();
7084    let local_var_content = local_var_resp.text().await?;
7085
7086    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7087        Ok(())
7088    } else {
7089        let local_var_entity: Option<VirtualizationInterfacesBulkDestroyError> =
7090            serde_json::from_str(&local_var_content).ok();
7091        let local_var_error = ResponseContent {
7092            status: local_var_status,
7093            content: local_var_content,
7094            entity: local_var_entity,
7095        };
7096        Err(Error::ResponseError(local_var_error))
7097    }
7098}
7099
7100/// Patch a list of interface objects.
7101pub async fn virtualization_interfaces_bulk_partial_update(
7102    configuration: &configuration::Configuration,
7103    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7104) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkPartialUpdateError>>
7105{
7106    let local_var_configuration = configuration;
7107
7108    let local_var_client = &local_var_configuration.client;
7109
7110    let local_var_uri_str = format!(
7111        "{}/api/virtualization/interfaces/",
7112        local_var_configuration.base_path
7113    );
7114    let mut local_var_req_builder =
7115        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7116
7117    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7118        local_var_req_builder =
7119            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7120    }
7121    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7122        let local_var_key = local_var_apikey.key.clone();
7123        let local_var_value = match local_var_apikey.prefix {
7124            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7125            None => local_var_key,
7126        };
7127        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7128    };
7129    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7130
7131    let local_var_req = local_var_req_builder.build()?;
7132    let local_var_resp = local_var_client.execute(local_var_req).await?;
7133
7134    let local_var_status = local_var_resp.status();
7135    let local_var_content = local_var_resp.text().await?;
7136
7137    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7138        serde_json::from_str(&local_var_content).map_err(Error::from)
7139    } else {
7140        let local_var_entity: Option<VirtualizationInterfacesBulkPartialUpdateError> =
7141            serde_json::from_str(&local_var_content).ok();
7142        let local_var_error = ResponseContent {
7143            status: local_var_status,
7144            content: local_var_content,
7145            entity: local_var_entity,
7146        };
7147        Err(Error::ResponseError(local_var_error))
7148    }
7149}
7150
7151/// Put a list of interface objects.
7152pub async fn virtualization_interfaces_bulk_update(
7153    configuration: &configuration::Configuration,
7154    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7155) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkUpdateError>> {
7156    let local_var_configuration = configuration;
7157
7158    let local_var_client = &local_var_configuration.client;
7159
7160    let local_var_uri_str = format!(
7161        "{}/api/virtualization/interfaces/",
7162        local_var_configuration.base_path
7163    );
7164    let mut local_var_req_builder =
7165        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7166
7167    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7168        local_var_req_builder =
7169            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7170    }
7171    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7172        let local_var_key = local_var_apikey.key.clone();
7173        let local_var_value = match local_var_apikey.prefix {
7174            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7175            None => local_var_key,
7176        };
7177        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7178    };
7179    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7180
7181    let local_var_req = local_var_req_builder.build()?;
7182    let local_var_resp = local_var_client.execute(local_var_req).await?;
7183
7184    let local_var_status = local_var_resp.status();
7185    let local_var_content = local_var_resp.text().await?;
7186
7187    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7188        serde_json::from_str(&local_var_content).map_err(Error::from)
7189    } else {
7190        let local_var_entity: Option<VirtualizationInterfacesBulkUpdateError> =
7191            serde_json::from_str(&local_var_content).ok();
7192        let local_var_error = ResponseContent {
7193            status: local_var_status,
7194            content: local_var_content,
7195            entity: local_var_entity,
7196        };
7197        Err(Error::ResponseError(local_var_error))
7198    }
7199}
7200
7201/// Post a list of interface objects.
7202pub async fn virtualization_interfaces_create(
7203    configuration: &configuration::Configuration,
7204    virtualization_interfaces_create_request: crate::models::VirtualizationInterfacesCreateRequest,
7205) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesCreateError>> {
7206    let local_var_configuration = configuration;
7207
7208    let local_var_client = &local_var_configuration.client;
7209
7210    let local_var_uri_str = format!(
7211        "{}/api/virtualization/interfaces/",
7212        local_var_configuration.base_path
7213    );
7214    let mut local_var_req_builder =
7215        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7216
7217    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7218        local_var_req_builder =
7219            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7220    }
7221    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7222        let local_var_key = local_var_apikey.key.clone();
7223        let local_var_value = match local_var_apikey.prefix {
7224            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7225            None => local_var_key,
7226        };
7227        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7228    };
7229    local_var_req_builder = local_var_req_builder.json(&virtualization_interfaces_create_request);
7230
7231    let local_var_req = local_var_req_builder.build()?;
7232    let local_var_resp = local_var_client.execute(local_var_req).await?;
7233
7234    let local_var_status = local_var_resp.status();
7235    let local_var_content = local_var_resp.text().await?;
7236
7237    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7238        serde_json::from_str(&local_var_content).map_err(Error::from)
7239    } else {
7240        let local_var_entity: Option<VirtualizationInterfacesCreateError> =
7241            serde_json::from_str(&local_var_content).ok();
7242        let local_var_error = ResponseContent {
7243            status: local_var_status,
7244            content: local_var_content,
7245            entity: local_var_entity,
7246        };
7247        Err(Error::ResponseError(local_var_error))
7248    }
7249}
7250
7251/// Delete a interface object.
7252pub async fn virtualization_interfaces_destroy(
7253    configuration: &configuration::Configuration,
7254    id: i32,
7255) -> Result<(), Error<VirtualizationInterfacesDestroyError>> {
7256    let local_var_configuration = configuration;
7257
7258    let local_var_client = &local_var_configuration.client;
7259
7260    let local_var_uri_str = format!(
7261        "{}/api/virtualization/interfaces/{id}/",
7262        local_var_configuration.base_path,
7263        id = id
7264    );
7265    let mut local_var_req_builder =
7266        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7267
7268    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7269        local_var_req_builder =
7270            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7271    }
7272    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7273        let local_var_key = local_var_apikey.key.clone();
7274        let local_var_value = match local_var_apikey.prefix {
7275            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7276            None => local_var_key,
7277        };
7278        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7279    };
7280
7281    let local_var_req = local_var_req_builder.build()?;
7282    let local_var_resp = local_var_client.execute(local_var_req).await?;
7283
7284    let local_var_status = local_var_resp.status();
7285    let local_var_content = local_var_resp.text().await?;
7286
7287    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7288        Ok(())
7289    } else {
7290        let local_var_entity: Option<VirtualizationInterfacesDestroyError> =
7291            serde_json::from_str(&local_var_content).ok();
7292        let local_var_error = ResponseContent {
7293            status: local_var_status,
7294            content: local_var_content,
7295            entity: local_var_entity,
7296        };
7297        Err(Error::ResponseError(local_var_error))
7298    }
7299}
7300
7301/// Get a list of interface objects.
7302pub async fn virtualization_interfaces_list(
7303    configuration: &configuration::Configuration,
7304    bridge_id: Option<Vec<i32>>,
7305    bridge_id__n: Option<Vec<i32>>,
7306    cluster: Option<Vec<String>>,
7307    cluster__n: Option<Vec<String>>,
7308    cluster_id: Option<Vec<i32>>,
7309    cluster_id__n: Option<Vec<i32>>,
7310    created: Option<Vec<String>>,
7311    created__empty: Option<Vec<String>>,
7312    created__gt: Option<Vec<String>>,
7313    created__gte: Option<Vec<String>>,
7314    created__lt: Option<Vec<String>>,
7315    created__lte: Option<Vec<String>>,
7316    created__n: Option<Vec<String>>,
7317    created_by_request: Option<&str>,
7318    description: Option<Vec<String>>,
7319    description__empty: Option<bool>,
7320    description__ic: Option<Vec<String>>,
7321    description__ie: Option<Vec<String>>,
7322    description__iew: Option<Vec<String>>,
7323    description__iregex: Option<Vec<String>>,
7324    description__isw: Option<Vec<String>>,
7325    description__n: Option<Vec<String>>,
7326    description__nic: Option<Vec<String>>,
7327    description__nie: Option<Vec<String>>,
7328    description__niew: Option<Vec<String>>,
7329    description__nisw: Option<Vec<String>>,
7330    description__regex: Option<Vec<String>>,
7331    enabled: Option<bool>,
7332    id: Option<Vec<i32>>,
7333    id__empty: Option<bool>,
7334    id__gt: Option<Vec<i32>>,
7335    id__gte: Option<Vec<i32>>,
7336    id__lt: Option<Vec<i32>>,
7337    id__lte: Option<Vec<i32>>,
7338    id__n: Option<Vec<i32>>,
7339    l2vpn: Option<Vec<i64>>,
7340    l2vpn__n: Option<Vec<i64>>,
7341    l2vpn_id: Option<Vec<i32>>,
7342    l2vpn_id__n: Option<Vec<i32>>,
7343    last_updated: Option<Vec<String>>,
7344    last_updated__empty: Option<Vec<String>>,
7345    last_updated__gt: Option<Vec<String>>,
7346    last_updated__gte: Option<Vec<String>>,
7347    last_updated__lt: Option<Vec<String>>,
7348    last_updated__lte: Option<Vec<String>>,
7349    last_updated__n: Option<Vec<String>>,
7350    limit: Option<i32>,
7351    mac_address: Option<Vec<String>>,
7352    mac_address__ic: Option<Vec<String>>,
7353    mac_address__ie: Option<Vec<String>>,
7354    mac_address__iew: Option<Vec<String>>,
7355    mac_address__iregex: Option<Vec<String>>,
7356    mac_address__isw: Option<Vec<String>>,
7357    mac_address__n: Option<Vec<String>>,
7358    mac_address__nic: Option<Vec<String>>,
7359    mac_address__nie: Option<Vec<String>>,
7360    mac_address__niew: Option<Vec<String>>,
7361    mac_address__nisw: Option<Vec<String>>,
7362    mac_address__regex: Option<Vec<String>>,
7363    mode: Option<Vec<String>>,
7364    mode__empty: Option<bool>,
7365    mode__ic: Option<Vec<String>>,
7366    mode__ie: Option<Vec<String>>,
7367    mode__iew: Option<Vec<String>>,
7368    mode__iregex: Option<Vec<String>>,
7369    mode__isw: Option<Vec<String>>,
7370    mode__n: Option<Vec<String>>,
7371    mode__nic: Option<Vec<String>>,
7372    mode__nie: Option<Vec<String>>,
7373    mode__niew: Option<Vec<String>>,
7374    mode__nisw: Option<Vec<String>>,
7375    mode__regex: Option<Vec<String>>,
7376    modified_by_request: Option<&str>,
7377    mtu: Option<Vec<i32>>,
7378    mtu__empty: Option<bool>,
7379    mtu__gt: Option<Vec<i32>>,
7380    mtu__gte: Option<Vec<i32>>,
7381    mtu__lt: Option<Vec<i32>>,
7382    mtu__lte: Option<Vec<i32>>,
7383    mtu__n: Option<Vec<i32>>,
7384    name: Option<Vec<String>>,
7385    name__empty: Option<bool>,
7386    name__ic: Option<Vec<String>>,
7387    name__ie: Option<Vec<String>>,
7388    name__iew: Option<Vec<String>>,
7389    name__iregex: Option<Vec<String>>,
7390    name__isw: Option<Vec<String>>,
7391    name__n: Option<Vec<String>>,
7392    name__nic: Option<Vec<String>>,
7393    name__nie: Option<Vec<String>>,
7394    name__niew: Option<Vec<String>>,
7395    name__nisw: Option<Vec<String>>,
7396    name__regex: Option<Vec<String>>,
7397    offset: Option<i32>,
7398    ordering: Option<&str>,
7399    owner: Option<Vec<String>>,
7400    owner__n: Option<Vec<String>>,
7401    owner_group: Option<Vec<String>>,
7402    owner_group__n: Option<Vec<String>>,
7403    owner_group_id: Option<Vec<i32>>,
7404    owner_group_id__n: Option<Vec<i32>>,
7405    owner_id: Option<Vec<i32>>,
7406    owner_id__n: Option<Vec<i32>>,
7407    parent_id: Option<Vec<i32>>,
7408    parent_id__n: Option<Vec<i32>>,
7409    primary_mac_address: Option<Vec<String>>,
7410    primary_mac_address__n: Option<Vec<String>>,
7411    primary_mac_address_id: Option<Vec<i32>>,
7412    primary_mac_address_id__n: Option<Vec<i32>>,
7413    q: Option<&str>,
7414    tag: Option<Vec<String>>,
7415    tag__n: Option<Vec<String>>,
7416    tag_id: Option<Vec<i32>>,
7417    tag_id__n: Option<Vec<i32>>,
7418    updated_by_request: Option<&str>,
7419    virtual_machine: Option<Vec<String>>,
7420    virtual_machine__n: Option<Vec<String>>,
7421    virtual_machine_id: Option<Vec<i32>>,
7422    virtual_machine_id__n: Option<Vec<i32>>,
7423    vlan: Option<&str>,
7424    vlan_id: Option<&str>,
7425    vlan_translation_policy: Option<Vec<String>>,
7426    vlan_translation_policy__n: Option<Vec<String>>,
7427    vlan_translation_policy_id: Option<Vec<i32>>,
7428    vlan_translation_policy_id__n: Option<Vec<i32>>,
7429    vrf: Option<Vec<String>>,
7430    vrf__n: Option<Vec<String>>,
7431    vrf_id: Option<Vec<i32>>,
7432    vrf_id__n: Option<Vec<i32>>,
7433) -> Result<crate::models::PaginatedVmInterfaceList, Error<VirtualizationInterfacesListError>> {
7434    let local_var_configuration = configuration;
7435
7436    let local_var_client = &local_var_configuration.client;
7437
7438    let local_var_uri_str = format!(
7439        "{}/api/virtualization/interfaces/",
7440        local_var_configuration.base_path
7441    );
7442    let mut local_var_req_builder =
7443        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7444
7445    if let Some(ref local_var_str) = bridge_id {
7446        local_var_req_builder = match "multi" {
7447            "multi" => local_var_req_builder.query(
7448                &local_var_str
7449                    .into_iter()
7450                    .map(|p| ("bridge_id".to_owned(), p.to_string()))
7451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7452            ),
7453            _ => local_var_req_builder.query(&[(
7454                "bridge_id",
7455                &local_var_str
7456                    .into_iter()
7457                    .map(|p| p.to_string())
7458                    .collect::<Vec<String>>()
7459                    .join(",")
7460                    .to_string(),
7461            )]),
7462        };
7463    }
7464    if let Some(ref local_var_str) = bridge_id__n {
7465        local_var_req_builder = match "multi" {
7466            "multi" => local_var_req_builder.query(
7467                &local_var_str
7468                    .into_iter()
7469                    .map(|p| ("bridge_id__n".to_owned(), p.to_string()))
7470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7471            ),
7472            _ => local_var_req_builder.query(&[(
7473                "bridge_id__n",
7474                &local_var_str
7475                    .into_iter()
7476                    .map(|p| p.to_string())
7477                    .collect::<Vec<String>>()
7478                    .join(",")
7479                    .to_string(),
7480            )]),
7481        };
7482    }
7483    if let Some(ref local_var_str) = cluster {
7484        local_var_req_builder = match "multi" {
7485            "multi" => local_var_req_builder.query(
7486                &local_var_str
7487                    .into_iter()
7488                    .map(|p| ("cluster".to_owned(), p.to_string()))
7489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7490            ),
7491            _ => local_var_req_builder.query(&[(
7492                "cluster",
7493                &local_var_str
7494                    .into_iter()
7495                    .map(|p| p.to_string())
7496                    .collect::<Vec<String>>()
7497                    .join(",")
7498                    .to_string(),
7499            )]),
7500        };
7501    }
7502    if let Some(ref local_var_str) = cluster__n {
7503        local_var_req_builder = match "multi" {
7504            "multi" => local_var_req_builder.query(
7505                &local_var_str
7506                    .into_iter()
7507                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
7508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7509            ),
7510            _ => local_var_req_builder.query(&[(
7511                "cluster__n",
7512                &local_var_str
7513                    .into_iter()
7514                    .map(|p| p.to_string())
7515                    .collect::<Vec<String>>()
7516                    .join(",")
7517                    .to_string(),
7518            )]),
7519        };
7520    }
7521    if let Some(ref local_var_str) = cluster_id {
7522        local_var_req_builder = match "multi" {
7523            "multi" => local_var_req_builder.query(
7524                &local_var_str
7525                    .into_iter()
7526                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
7527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7528            ),
7529            _ => local_var_req_builder.query(&[(
7530                "cluster_id",
7531                &local_var_str
7532                    .into_iter()
7533                    .map(|p| p.to_string())
7534                    .collect::<Vec<String>>()
7535                    .join(",")
7536                    .to_string(),
7537            )]),
7538        };
7539    }
7540    if let Some(ref local_var_str) = cluster_id__n {
7541        local_var_req_builder = match "multi" {
7542            "multi" => local_var_req_builder.query(
7543                &local_var_str
7544                    .into_iter()
7545                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
7546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7547            ),
7548            _ => local_var_req_builder.query(&[(
7549                "cluster_id__n",
7550                &local_var_str
7551                    .into_iter()
7552                    .map(|p| p.to_string())
7553                    .collect::<Vec<String>>()
7554                    .join(",")
7555                    .to_string(),
7556            )]),
7557        };
7558    }
7559    if let Some(ref local_var_str) = created {
7560        local_var_req_builder = match "multi" {
7561            "multi" => local_var_req_builder.query(
7562                &local_var_str
7563                    .into_iter()
7564                    .map(|p| ("created".to_owned(), p.to_string()))
7565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7566            ),
7567            _ => local_var_req_builder.query(&[(
7568                "created",
7569                &local_var_str
7570                    .into_iter()
7571                    .map(|p| p.to_string())
7572                    .collect::<Vec<String>>()
7573                    .join(",")
7574                    .to_string(),
7575            )]),
7576        };
7577    }
7578    if let Some(ref local_var_str) = created__empty {
7579        local_var_req_builder = match "multi" {
7580            "multi" => local_var_req_builder.query(
7581                &local_var_str
7582                    .into_iter()
7583                    .map(|p| ("created__empty".to_owned(), p.to_string()))
7584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7585            ),
7586            _ => local_var_req_builder.query(&[(
7587                "created__empty",
7588                &local_var_str
7589                    .into_iter()
7590                    .map(|p| p.to_string())
7591                    .collect::<Vec<String>>()
7592                    .join(",")
7593                    .to_string(),
7594            )]),
7595        };
7596    }
7597    if let Some(ref local_var_str) = created__gt {
7598        local_var_req_builder = match "multi" {
7599            "multi" => local_var_req_builder.query(
7600                &local_var_str
7601                    .into_iter()
7602                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7604            ),
7605            _ => local_var_req_builder.query(&[(
7606                "created__gt",
7607                &local_var_str
7608                    .into_iter()
7609                    .map(|p| p.to_string())
7610                    .collect::<Vec<String>>()
7611                    .join(",")
7612                    .to_string(),
7613            )]),
7614        };
7615    }
7616    if let Some(ref local_var_str) = created__gte {
7617        local_var_req_builder = match "multi" {
7618            "multi" => local_var_req_builder.query(
7619                &local_var_str
7620                    .into_iter()
7621                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7623            ),
7624            _ => local_var_req_builder.query(&[(
7625                "created__gte",
7626                &local_var_str
7627                    .into_iter()
7628                    .map(|p| p.to_string())
7629                    .collect::<Vec<String>>()
7630                    .join(",")
7631                    .to_string(),
7632            )]),
7633        };
7634    }
7635    if let Some(ref local_var_str) = created__lt {
7636        local_var_req_builder = match "multi" {
7637            "multi" => local_var_req_builder.query(
7638                &local_var_str
7639                    .into_iter()
7640                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7642            ),
7643            _ => local_var_req_builder.query(&[(
7644                "created__lt",
7645                &local_var_str
7646                    .into_iter()
7647                    .map(|p| p.to_string())
7648                    .collect::<Vec<String>>()
7649                    .join(",")
7650                    .to_string(),
7651            )]),
7652        };
7653    }
7654    if let Some(ref local_var_str) = created__lte {
7655        local_var_req_builder = match "multi" {
7656            "multi" => local_var_req_builder.query(
7657                &local_var_str
7658                    .into_iter()
7659                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7661            ),
7662            _ => local_var_req_builder.query(&[(
7663                "created__lte",
7664                &local_var_str
7665                    .into_iter()
7666                    .map(|p| p.to_string())
7667                    .collect::<Vec<String>>()
7668                    .join(",")
7669                    .to_string(),
7670            )]),
7671        };
7672    }
7673    if let Some(ref local_var_str) = created__n {
7674        local_var_req_builder = match "multi" {
7675            "multi" => local_var_req_builder.query(
7676                &local_var_str
7677                    .into_iter()
7678                    .map(|p| ("created__n".to_owned(), p.to_string()))
7679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7680            ),
7681            _ => local_var_req_builder.query(&[(
7682                "created__n",
7683                &local_var_str
7684                    .into_iter()
7685                    .map(|p| p.to_string())
7686                    .collect::<Vec<String>>()
7687                    .join(",")
7688                    .to_string(),
7689            )]),
7690        };
7691    }
7692    if let Some(ref local_var_str) = created_by_request {
7693        local_var_req_builder =
7694            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
7695    }
7696    if let Some(ref local_var_str) = description {
7697        local_var_req_builder = match "multi" {
7698            "multi" => local_var_req_builder.query(
7699                &local_var_str
7700                    .into_iter()
7701                    .map(|p| ("description".to_owned(), p.to_string()))
7702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7703            ),
7704            _ => local_var_req_builder.query(&[(
7705                "description",
7706                &local_var_str
7707                    .into_iter()
7708                    .map(|p| p.to_string())
7709                    .collect::<Vec<String>>()
7710                    .join(",")
7711                    .to_string(),
7712            )]),
7713        };
7714    }
7715    if let Some(ref local_var_str) = description__empty {
7716        local_var_req_builder =
7717            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
7718    }
7719    if let Some(ref local_var_str) = description__ic {
7720        local_var_req_builder = match "multi" {
7721            "multi" => local_var_req_builder.query(
7722                &local_var_str
7723                    .into_iter()
7724                    .map(|p| ("description__ic".to_owned(), p.to_string()))
7725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7726            ),
7727            _ => local_var_req_builder.query(&[(
7728                "description__ic",
7729                &local_var_str
7730                    .into_iter()
7731                    .map(|p| p.to_string())
7732                    .collect::<Vec<String>>()
7733                    .join(",")
7734                    .to_string(),
7735            )]),
7736        };
7737    }
7738    if let Some(ref local_var_str) = description__ie {
7739        local_var_req_builder = match "multi" {
7740            "multi" => local_var_req_builder.query(
7741                &local_var_str
7742                    .into_iter()
7743                    .map(|p| ("description__ie".to_owned(), p.to_string()))
7744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7745            ),
7746            _ => local_var_req_builder.query(&[(
7747                "description__ie",
7748                &local_var_str
7749                    .into_iter()
7750                    .map(|p| p.to_string())
7751                    .collect::<Vec<String>>()
7752                    .join(",")
7753                    .to_string(),
7754            )]),
7755        };
7756    }
7757    if let Some(ref local_var_str) = description__iew {
7758        local_var_req_builder = match "multi" {
7759            "multi" => local_var_req_builder.query(
7760                &local_var_str
7761                    .into_iter()
7762                    .map(|p| ("description__iew".to_owned(), p.to_string()))
7763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7764            ),
7765            _ => local_var_req_builder.query(&[(
7766                "description__iew",
7767                &local_var_str
7768                    .into_iter()
7769                    .map(|p| p.to_string())
7770                    .collect::<Vec<String>>()
7771                    .join(",")
7772                    .to_string(),
7773            )]),
7774        };
7775    }
7776    if let Some(ref local_var_str) = description__iregex {
7777        local_var_req_builder = match "multi" {
7778            "multi" => local_var_req_builder.query(
7779                &local_var_str
7780                    .into_iter()
7781                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
7782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7783            ),
7784            _ => local_var_req_builder.query(&[(
7785                "description__iregex",
7786                &local_var_str
7787                    .into_iter()
7788                    .map(|p| p.to_string())
7789                    .collect::<Vec<String>>()
7790                    .join(",")
7791                    .to_string(),
7792            )]),
7793        };
7794    }
7795    if let Some(ref local_var_str) = description__isw {
7796        local_var_req_builder = match "multi" {
7797            "multi" => local_var_req_builder.query(
7798                &local_var_str
7799                    .into_iter()
7800                    .map(|p| ("description__isw".to_owned(), p.to_string()))
7801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7802            ),
7803            _ => local_var_req_builder.query(&[(
7804                "description__isw",
7805                &local_var_str
7806                    .into_iter()
7807                    .map(|p| p.to_string())
7808                    .collect::<Vec<String>>()
7809                    .join(",")
7810                    .to_string(),
7811            )]),
7812        };
7813    }
7814    if let Some(ref local_var_str) = description__n {
7815        local_var_req_builder = match "multi" {
7816            "multi" => local_var_req_builder.query(
7817                &local_var_str
7818                    .into_iter()
7819                    .map(|p| ("description__n".to_owned(), p.to_string()))
7820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7821            ),
7822            _ => local_var_req_builder.query(&[(
7823                "description__n",
7824                &local_var_str
7825                    .into_iter()
7826                    .map(|p| p.to_string())
7827                    .collect::<Vec<String>>()
7828                    .join(",")
7829                    .to_string(),
7830            )]),
7831        };
7832    }
7833    if let Some(ref local_var_str) = description__nic {
7834        local_var_req_builder = match "multi" {
7835            "multi" => local_var_req_builder.query(
7836                &local_var_str
7837                    .into_iter()
7838                    .map(|p| ("description__nic".to_owned(), p.to_string()))
7839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7840            ),
7841            _ => local_var_req_builder.query(&[(
7842                "description__nic",
7843                &local_var_str
7844                    .into_iter()
7845                    .map(|p| p.to_string())
7846                    .collect::<Vec<String>>()
7847                    .join(",")
7848                    .to_string(),
7849            )]),
7850        };
7851    }
7852    if let Some(ref local_var_str) = description__nie {
7853        local_var_req_builder = match "multi" {
7854            "multi" => local_var_req_builder.query(
7855                &local_var_str
7856                    .into_iter()
7857                    .map(|p| ("description__nie".to_owned(), p.to_string()))
7858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7859            ),
7860            _ => local_var_req_builder.query(&[(
7861                "description__nie",
7862                &local_var_str
7863                    .into_iter()
7864                    .map(|p| p.to_string())
7865                    .collect::<Vec<String>>()
7866                    .join(",")
7867                    .to_string(),
7868            )]),
7869        };
7870    }
7871    if let Some(ref local_var_str) = description__niew {
7872        local_var_req_builder = match "multi" {
7873            "multi" => local_var_req_builder.query(
7874                &local_var_str
7875                    .into_iter()
7876                    .map(|p| ("description__niew".to_owned(), p.to_string()))
7877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7878            ),
7879            _ => local_var_req_builder.query(&[(
7880                "description__niew",
7881                &local_var_str
7882                    .into_iter()
7883                    .map(|p| p.to_string())
7884                    .collect::<Vec<String>>()
7885                    .join(",")
7886                    .to_string(),
7887            )]),
7888        };
7889    }
7890    if let Some(ref local_var_str) = description__nisw {
7891        local_var_req_builder = match "multi" {
7892            "multi" => local_var_req_builder.query(
7893                &local_var_str
7894                    .into_iter()
7895                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
7896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7897            ),
7898            _ => local_var_req_builder.query(&[(
7899                "description__nisw",
7900                &local_var_str
7901                    .into_iter()
7902                    .map(|p| p.to_string())
7903                    .collect::<Vec<String>>()
7904                    .join(",")
7905                    .to_string(),
7906            )]),
7907        };
7908    }
7909    if let Some(ref local_var_str) = description__regex {
7910        local_var_req_builder = match "multi" {
7911            "multi" => local_var_req_builder.query(
7912                &local_var_str
7913                    .into_iter()
7914                    .map(|p| ("description__regex".to_owned(), p.to_string()))
7915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7916            ),
7917            _ => local_var_req_builder.query(&[(
7918                "description__regex",
7919                &local_var_str
7920                    .into_iter()
7921                    .map(|p| p.to_string())
7922                    .collect::<Vec<String>>()
7923                    .join(",")
7924                    .to_string(),
7925            )]),
7926        };
7927    }
7928    if let Some(ref local_var_str) = enabled {
7929        local_var_req_builder =
7930            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
7931    }
7932    if let Some(ref local_var_str) = id {
7933        local_var_req_builder = match "multi" {
7934            "multi" => local_var_req_builder.query(
7935                &local_var_str
7936                    .into_iter()
7937                    .map(|p| ("id".to_owned(), p.to_string()))
7938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7939            ),
7940            _ => local_var_req_builder.query(&[(
7941                "id",
7942                &local_var_str
7943                    .into_iter()
7944                    .map(|p| p.to_string())
7945                    .collect::<Vec<String>>()
7946                    .join(",")
7947                    .to_string(),
7948            )]),
7949        };
7950    }
7951    if let Some(ref local_var_str) = id__empty {
7952        local_var_req_builder =
7953            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7954    }
7955    if let Some(ref local_var_str) = id__gt {
7956        local_var_req_builder = match "multi" {
7957            "multi" => local_var_req_builder.query(
7958                &local_var_str
7959                    .into_iter()
7960                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7962            ),
7963            _ => local_var_req_builder.query(&[(
7964                "id__gt",
7965                &local_var_str
7966                    .into_iter()
7967                    .map(|p| p.to_string())
7968                    .collect::<Vec<String>>()
7969                    .join(",")
7970                    .to_string(),
7971            )]),
7972        };
7973    }
7974    if let Some(ref local_var_str) = id__gte {
7975        local_var_req_builder = match "multi" {
7976            "multi" => local_var_req_builder.query(
7977                &local_var_str
7978                    .into_iter()
7979                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7981            ),
7982            _ => local_var_req_builder.query(&[(
7983                "id__gte",
7984                &local_var_str
7985                    .into_iter()
7986                    .map(|p| p.to_string())
7987                    .collect::<Vec<String>>()
7988                    .join(",")
7989                    .to_string(),
7990            )]),
7991        };
7992    }
7993    if let Some(ref local_var_str) = id__lt {
7994        local_var_req_builder = match "multi" {
7995            "multi" => local_var_req_builder.query(
7996                &local_var_str
7997                    .into_iter()
7998                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8000            ),
8001            _ => local_var_req_builder.query(&[(
8002                "id__lt",
8003                &local_var_str
8004                    .into_iter()
8005                    .map(|p| p.to_string())
8006                    .collect::<Vec<String>>()
8007                    .join(",")
8008                    .to_string(),
8009            )]),
8010        };
8011    }
8012    if let Some(ref local_var_str) = id__lte {
8013        local_var_req_builder = match "multi" {
8014            "multi" => local_var_req_builder.query(
8015                &local_var_str
8016                    .into_iter()
8017                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8019            ),
8020            _ => local_var_req_builder.query(&[(
8021                "id__lte",
8022                &local_var_str
8023                    .into_iter()
8024                    .map(|p| p.to_string())
8025                    .collect::<Vec<String>>()
8026                    .join(",")
8027                    .to_string(),
8028            )]),
8029        };
8030    }
8031    if let Some(ref local_var_str) = id__n {
8032        local_var_req_builder = match "multi" {
8033            "multi" => local_var_req_builder.query(
8034                &local_var_str
8035                    .into_iter()
8036                    .map(|p| ("id__n".to_owned(), p.to_string()))
8037                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8038            ),
8039            _ => local_var_req_builder.query(&[(
8040                "id__n",
8041                &local_var_str
8042                    .into_iter()
8043                    .map(|p| p.to_string())
8044                    .collect::<Vec<String>>()
8045                    .join(",")
8046                    .to_string(),
8047            )]),
8048        };
8049    }
8050    if let Some(ref local_var_str) = l2vpn {
8051        local_var_req_builder = match "multi" {
8052            "multi" => local_var_req_builder.query(
8053                &local_var_str
8054                    .into_iter()
8055                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
8056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8057            ),
8058            _ => local_var_req_builder.query(&[(
8059                "l2vpn",
8060                &local_var_str
8061                    .into_iter()
8062                    .map(|p| p.to_string())
8063                    .collect::<Vec<String>>()
8064                    .join(",")
8065                    .to_string(),
8066            )]),
8067        };
8068    }
8069    if let Some(ref local_var_str) = l2vpn__n {
8070        local_var_req_builder = match "multi" {
8071            "multi" => local_var_req_builder.query(
8072                &local_var_str
8073                    .into_iter()
8074                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
8075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8076            ),
8077            _ => local_var_req_builder.query(&[(
8078                "l2vpn__n",
8079                &local_var_str
8080                    .into_iter()
8081                    .map(|p| p.to_string())
8082                    .collect::<Vec<String>>()
8083                    .join(",")
8084                    .to_string(),
8085            )]),
8086        };
8087    }
8088    if let Some(ref local_var_str) = l2vpn_id {
8089        local_var_req_builder = match "multi" {
8090            "multi" => local_var_req_builder.query(
8091                &local_var_str
8092                    .into_iter()
8093                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
8094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8095            ),
8096            _ => local_var_req_builder.query(&[(
8097                "l2vpn_id",
8098                &local_var_str
8099                    .into_iter()
8100                    .map(|p| p.to_string())
8101                    .collect::<Vec<String>>()
8102                    .join(",")
8103                    .to_string(),
8104            )]),
8105        };
8106    }
8107    if let Some(ref local_var_str) = l2vpn_id__n {
8108        local_var_req_builder = match "multi" {
8109            "multi" => local_var_req_builder.query(
8110                &local_var_str
8111                    .into_iter()
8112                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
8113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8114            ),
8115            _ => local_var_req_builder.query(&[(
8116                "l2vpn_id__n",
8117                &local_var_str
8118                    .into_iter()
8119                    .map(|p| p.to_string())
8120                    .collect::<Vec<String>>()
8121                    .join(",")
8122                    .to_string(),
8123            )]),
8124        };
8125    }
8126    if let Some(ref local_var_str) = last_updated {
8127        local_var_req_builder = match "multi" {
8128            "multi" => local_var_req_builder.query(
8129                &local_var_str
8130                    .into_iter()
8131                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8133            ),
8134            _ => local_var_req_builder.query(&[(
8135                "last_updated",
8136                &local_var_str
8137                    .into_iter()
8138                    .map(|p| p.to_string())
8139                    .collect::<Vec<String>>()
8140                    .join(",")
8141                    .to_string(),
8142            )]),
8143        };
8144    }
8145    if let Some(ref local_var_str) = last_updated__empty {
8146        local_var_req_builder = match "multi" {
8147            "multi" => local_var_req_builder.query(
8148                &local_var_str
8149                    .into_iter()
8150                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8152            ),
8153            _ => local_var_req_builder.query(&[(
8154                "last_updated__empty",
8155                &local_var_str
8156                    .into_iter()
8157                    .map(|p| p.to_string())
8158                    .collect::<Vec<String>>()
8159                    .join(",")
8160                    .to_string(),
8161            )]),
8162        };
8163    }
8164    if let Some(ref local_var_str) = last_updated__gt {
8165        local_var_req_builder = match "multi" {
8166            "multi" => local_var_req_builder.query(
8167                &local_var_str
8168                    .into_iter()
8169                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8171            ),
8172            _ => local_var_req_builder.query(&[(
8173                "last_updated__gt",
8174                &local_var_str
8175                    .into_iter()
8176                    .map(|p| p.to_string())
8177                    .collect::<Vec<String>>()
8178                    .join(",")
8179                    .to_string(),
8180            )]),
8181        };
8182    }
8183    if let Some(ref local_var_str) = last_updated__gte {
8184        local_var_req_builder = match "multi" {
8185            "multi" => local_var_req_builder.query(
8186                &local_var_str
8187                    .into_iter()
8188                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8190            ),
8191            _ => local_var_req_builder.query(&[(
8192                "last_updated__gte",
8193                &local_var_str
8194                    .into_iter()
8195                    .map(|p| p.to_string())
8196                    .collect::<Vec<String>>()
8197                    .join(",")
8198                    .to_string(),
8199            )]),
8200        };
8201    }
8202    if let Some(ref local_var_str) = last_updated__lt {
8203        local_var_req_builder = match "multi" {
8204            "multi" => local_var_req_builder.query(
8205                &local_var_str
8206                    .into_iter()
8207                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8209            ),
8210            _ => local_var_req_builder.query(&[(
8211                "last_updated__lt",
8212                &local_var_str
8213                    .into_iter()
8214                    .map(|p| p.to_string())
8215                    .collect::<Vec<String>>()
8216                    .join(",")
8217                    .to_string(),
8218            )]),
8219        };
8220    }
8221    if let Some(ref local_var_str) = last_updated__lte {
8222        local_var_req_builder = match "multi" {
8223            "multi" => local_var_req_builder.query(
8224                &local_var_str
8225                    .into_iter()
8226                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8228            ),
8229            _ => local_var_req_builder.query(&[(
8230                "last_updated__lte",
8231                &local_var_str
8232                    .into_iter()
8233                    .map(|p| p.to_string())
8234                    .collect::<Vec<String>>()
8235                    .join(",")
8236                    .to_string(),
8237            )]),
8238        };
8239    }
8240    if let Some(ref local_var_str) = last_updated__n {
8241        local_var_req_builder = match "multi" {
8242            "multi" => local_var_req_builder.query(
8243                &local_var_str
8244                    .into_iter()
8245                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8247            ),
8248            _ => local_var_req_builder.query(&[(
8249                "last_updated__n",
8250                &local_var_str
8251                    .into_iter()
8252                    .map(|p| p.to_string())
8253                    .collect::<Vec<String>>()
8254                    .join(",")
8255                    .to_string(),
8256            )]),
8257        };
8258    }
8259    if let Some(ref local_var_str) = limit {
8260        local_var_req_builder =
8261            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8262    }
8263    if let Some(ref local_var_str) = mac_address {
8264        local_var_req_builder = match "multi" {
8265            "multi" => local_var_req_builder.query(
8266                &local_var_str
8267                    .into_iter()
8268                    .map(|p| ("mac_address".to_owned(), p.to_string()))
8269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8270            ),
8271            _ => local_var_req_builder.query(&[(
8272                "mac_address",
8273                &local_var_str
8274                    .into_iter()
8275                    .map(|p| p.to_string())
8276                    .collect::<Vec<String>>()
8277                    .join(",")
8278                    .to_string(),
8279            )]),
8280        };
8281    }
8282    if let Some(ref local_var_str) = mac_address__ic {
8283        local_var_req_builder = match "multi" {
8284            "multi" => local_var_req_builder.query(
8285                &local_var_str
8286                    .into_iter()
8287                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
8288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8289            ),
8290            _ => local_var_req_builder.query(&[(
8291                "mac_address__ic",
8292                &local_var_str
8293                    .into_iter()
8294                    .map(|p| p.to_string())
8295                    .collect::<Vec<String>>()
8296                    .join(",")
8297                    .to_string(),
8298            )]),
8299        };
8300    }
8301    if let Some(ref local_var_str) = mac_address__ie {
8302        local_var_req_builder = match "multi" {
8303            "multi" => local_var_req_builder.query(
8304                &local_var_str
8305                    .into_iter()
8306                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
8307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8308            ),
8309            _ => local_var_req_builder.query(&[(
8310                "mac_address__ie",
8311                &local_var_str
8312                    .into_iter()
8313                    .map(|p| p.to_string())
8314                    .collect::<Vec<String>>()
8315                    .join(",")
8316                    .to_string(),
8317            )]),
8318        };
8319    }
8320    if let Some(ref local_var_str) = mac_address__iew {
8321        local_var_req_builder = match "multi" {
8322            "multi" => local_var_req_builder.query(
8323                &local_var_str
8324                    .into_iter()
8325                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
8326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8327            ),
8328            _ => local_var_req_builder.query(&[(
8329                "mac_address__iew",
8330                &local_var_str
8331                    .into_iter()
8332                    .map(|p| p.to_string())
8333                    .collect::<Vec<String>>()
8334                    .join(",")
8335                    .to_string(),
8336            )]),
8337        };
8338    }
8339    if let Some(ref local_var_str) = mac_address__iregex {
8340        local_var_req_builder = match "multi" {
8341            "multi" => local_var_req_builder.query(
8342                &local_var_str
8343                    .into_iter()
8344                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
8345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8346            ),
8347            _ => local_var_req_builder.query(&[(
8348                "mac_address__iregex",
8349                &local_var_str
8350                    .into_iter()
8351                    .map(|p| p.to_string())
8352                    .collect::<Vec<String>>()
8353                    .join(",")
8354                    .to_string(),
8355            )]),
8356        };
8357    }
8358    if let Some(ref local_var_str) = mac_address__isw {
8359        local_var_req_builder = match "multi" {
8360            "multi" => local_var_req_builder.query(
8361                &local_var_str
8362                    .into_iter()
8363                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
8364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8365            ),
8366            _ => local_var_req_builder.query(&[(
8367                "mac_address__isw",
8368                &local_var_str
8369                    .into_iter()
8370                    .map(|p| p.to_string())
8371                    .collect::<Vec<String>>()
8372                    .join(",")
8373                    .to_string(),
8374            )]),
8375        };
8376    }
8377    if let Some(ref local_var_str) = mac_address__n {
8378        local_var_req_builder = match "multi" {
8379            "multi" => local_var_req_builder.query(
8380                &local_var_str
8381                    .into_iter()
8382                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
8383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8384            ),
8385            _ => local_var_req_builder.query(&[(
8386                "mac_address__n",
8387                &local_var_str
8388                    .into_iter()
8389                    .map(|p| p.to_string())
8390                    .collect::<Vec<String>>()
8391                    .join(",")
8392                    .to_string(),
8393            )]),
8394        };
8395    }
8396    if let Some(ref local_var_str) = mac_address__nic {
8397        local_var_req_builder = match "multi" {
8398            "multi" => local_var_req_builder.query(
8399                &local_var_str
8400                    .into_iter()
8401                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
8402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8403            ),
8404            _ => local_var_req_builder.query(&[(
8405                "mac_address__nic",
8406                &local_var_str
8407                    .into_iter()
8408                    .map(|p| p.to_string())
8409                    .collect::<Vec<String>>()
8410                    .join(",")
8411                    .to_string(),
8412            )]),
8413        };
8414    }
8415    if let Some(ref local_var_str) = mac_address__nie {
8416        local_var_req_builder = match "multi" {
8417            "multi" => local_var_req_builder.query(
8418                &local_var_str
8419                    .into_iter()
8420                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
8421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8422            ),
8423            _ => local_var_req_builder.query(&[(
8424                "mac_address__nie",
8425                &local_var_str
8426                    .into_iter()
8427                    .map(|p| p.to_string())
8428                    .collect::<Vec<String>>()
8429                    .join(",")
8430                    .to_string(),
8431            )]),
8432        };
8433    }
8434    if let Some(ref local_var_str) = mac_address__niew {
8435        local_var_req_builder = match "multi" {
8436            "multi" => local_var_req_builder.query(
8437                &local_var_str
8438                    .into_iter()
8439                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
8440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8441            ),
8442            _ => local_var_req_builder.query(&[(
8443                "mac_address__niew",
8444                &local_var_str
8445                    .into_iter()
8446                    .map(|p| p.to_string())
8447                    .collect::<Vec<String>>()
8448                    .join(",")
8449                    .to_string(),
8450            )]),
8451        };
8452    }
8453    if let Some(ref local_var_str) = mac_address__nisw {
8454        local_var_req_builder = match "multi" {
8455            "multi" => local_var_req_builder.query(
8456                &local_var_str
8457                    .into_iter()
8458                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
8459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8460            ),
8461            _ => local_var_req_builder.query(&[(
8462                "mac_address__nisw",
8463                &local_var_str
8464                    .into_iter()
8465                    .map(|p| p.to_string())
8466                    .collect::<Vec<String>>()
8467                    .join(",")
8468                    .to_string(),
8469            )]),
8470        };
8471    }
8472    if let Some(ref local_var_str) = mac_address__regex {
8473        local_var_req_builder = match "multi" {
8474            "multi" => local_var_req_builder.query(
8475                &local_var_str
8476                    .into_iter()
8477                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
8478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8479            ),
8480            _ => local_var_req_builder.query(&[(
8481                "mac_address__regex",
8482                &local_var_str
8483                    .into_iter()
8484                    .map(|p| p.to_string())
8485                    .collect::<Vec<String>>()
8486                    .join(",")
8487                    .to_string(),
8488            )]),
8489        };
8490    }
8491    if let Some(ref local_var_str) = mode {
8492        local_var_req_builder = match "multi" {
8493            "multi" => local_var_req_builder.query(
8494                &local_var_str
8495                    .into_iter()
8496                    .map(|p| ("mode".to_owned(), p.to_string()))
8497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8498            ),
8499            _ => local_var_req_builder.query(&[(
8500                "mode",
8501                &local_var_str
8502                    .into_iter()
8503                    .map(|p| p.to_string())
8504                    .collect::<Vec<String>>()
8505                    .join(",")
8506                    .to_string(),
8507            )]),
8508        };
8509    }
8510    if let Some(ref local_var_str) = mode__empty {
8511        local_var_req_builder =
8512            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
8513    }
8514    if let Some(ref local_var_str) = mode__ic {
8515        local_var_req_builder = match "multi" {
8516            "multi" => local_var_req_builder.query(
8517                &local_var_str
8518                    .into_iter()
8519                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8521            ),
8522            _ => local_var_req_builder.query(&[(
8523                "mode__ic",
8524                &local_var_str
8525                    .into_iter()
8526                    .map(|p| p.to_string())
8527                    .collect::<Vec<String>>()
8528                    .join(",")
8529                    .to_string(),
8530            )]),
8531        };
8532    }
8533    if let Some(ref local_var_str) = mode__ie {
8534        local_var_req_builder = match "multi" {
8535            "multi" => local_var_req_builder.query(
8536                &local_var_str
8537                    .into_iter()
8538                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8540            ),
8541            _ => local_var_req_builder.query(&[(
8542                "mode__ie",
8543                &local_var_str
8544                    .into_iter()
8545                    .map(|p| p.to_string())
8546                    .collect::<Vec<String>>()
8547                    .join(",")
8548                    .to_string(),
8549            )]),
8550        };
8551    }
8552    if let Some(ref local_var_str) = mode__iew {
8553        local_var_req_builder = match "multi" {
8554            "multi" => local_var_req_builder.query(
8555                &local_var_str
8556                    .into_iter()
8557                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8559            ),
8560            _ => local_var_req_builder.query(&[(
8561                "mode__iew",
8562                &local_var_str
8563                    .into_iter()
8564                    .map(|p| p.to_string())
8565                    .collect::<Vec<String>>()
8566                    .join(",")
8567                    .to_string(),
8568            )]),
8569        };
8570    }
8571    if let Some(ref local_var_str) = mode__iregex {
8572        local_var_req_builder = match "multi" {
8573            "multi" => local_var_req_builder.query(
8574                &local_var_str
8575                    .into_iter()
8576                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8578            ),
8579            _ => local_var_req_builder.query(&[(
8580                "mode__iregex",
8581                &local_var_str
8582                    .into_iter()
8583                    .map(|p| p.to_string())
8584                    .collect::<Vec<String>>()
8585                    .join(",")
8586                    .to_string(),
8587            )]),
8588        };
8589    }
8590    if let Some(ref local_var_str) = mode__isw {
8591        local_var_req_builder = match "multi" {
8592            "multi" => local_var_req_builder.query(
8593                &local_var_str
8594                    .into_iter()
8595                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8597            ),
8598            _ => local_var_req_builder.query(&[(
8599                "mode__isw",
8600                &local_var_str
8601                    .into_iter()
8602                    .map(|p| p.to_string())
8603                    .collect::<Vec<String>>()
8604                    .join(",")
8605                    .to_string(),
8606            )]),
8607        };
8608    }
8609    if let Some(ref local_var_str) = mode__n {
8610        local_var_req_builder = match "multi" {
8611            "multi" => local_var_req_builder.query(
8612                &local_var_str
8613                    .into_iter()
8614                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8616            ),
8617            _ => local_var_req_builder.query(&[(
8618                "mode__n",
8619                &local_var_str
8620                    .into_iter()
8621                    .map(|p| p.to_string())
8622                    .collect::<Vec<String>>()
8623                    .join(",")
8624                    .to_string(),
8625            )]),
8626        };
8627    }
8628    if let Some(ref local_var_str) = mode__nic {
8629        local_var_req_builder = match "multi" {
8630            "multi" => local_var_req_builder.query(
8631                &local_var_str
8632                    .into_iter()
8633                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8635            ),
8636            _ => local_var_req_builder.query(&[(
8637                "mode__nic",
8638                &local_var_str
8639                    .into_iter()
8640                    .map(|p| p.to_string())
8641                    .collect::<Vec<String>>()
8642                    .join(",")
8643                    .to_string(),
8644            )]),
8645        };
8646    }
8647    if let Some(ref local_var_str) = mode__nie {
8648        local_var_req_builder = match "multi" {
8649            "multi" => local_var_req_builder.query(
8650                &local_var_str
8651                    .into_iter()
8652                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8654            ),
8655            _ => local_var_req_builder.query(&[(
8656                "mode__nie",
8657                &local_var_str
8658                    .into_iter()
8659                    .map(|p| p.to_string())
8660                    .collect::<Vec<String>>()
8661                    .join(",")
8662                    .to_string(),
8663            )]),
8664        };
8665    }
8666    if let Some(ref local_var_str) = mode__niew {
8667        local_var_req_builder = match "multi" {
8668            "multi" => local_var_req_builder.query(
8669                &local_var_str
8670                    .into_iter()
8671                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8673            ),
8674            _ => local_var_req_builder.query(&[(
8675                "mode__niew",
8676                &local_var_str
8677                    .into_iter()
8678                    .map(|p| p.to_string())
8679                    .collect::<Vec<String>>()
8680                    .join(",")
8681                    .to_string(),
8682            )]),
8683        };
8684    }
8685    if let Some(ref local_var_str) = mode__nisw {
8686        local_var_req_builder = match "multi" {
8687            "multi" => local_var_req_builder.query(
8688                &local_var_str
8689                    .into_iter()
8690                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8692            ),
8693            _ => local_var_req_builder.query(&[(
8694                "mode__nisw",
8695                &local_var_str
8696                    .into_iter()
8697                    .map(|p| p.to_string())
8698                    .collect::<Vec<String>>()
8699                    .join(",")
8700                    .to_string(),
8701            )]),
8702        };
8703    }
8704    if let Some(ref local_var_str) = mode__regex {
8705        local_var_req_builder = match "multi" {
8706            "multi" => local_var_req_builder.query(
8707                &local_var_str
8708                    .into_iter()
8709                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
8710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8711            ),
8712            _ => local_var_req_builder.query(&[(
8713                "mode__regex",
8714                &local_var_str
8715                    .into_iter()
8716                    .map(|p| p.to_string())
8717                    .collect::<Vec<String>>()
8718                    .join(",")
8719                    .to_string(),
8720            )]),
8721        };
8722    }
8723    if let Some(ref local_var_str) = modified_by_request {
8724        local_var_req_builder =
8725            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8726    }
8727    if let Some(ref local_var_str) = mtu {
8728        local_var_req_builder = match "multi" {
8729            "multi" => local_var_req_builder.query(
8730                &local_var_str
8731                    .into_iter()
8732                    .map(|p| ("mtu".to_owned(), p.to_string()))
8733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8734            ),
8735            _ => local_var_req_builder.query(&[(
8736                "mtu",
8737                &local_var_str
8738                    .into_iter()
8739                    .map(|p| p.to_string())
8740                    .collect::<Vec<String>>()
8741                    .join(",")
8742                    .to_string(),
8743            )]),
8744        };
8745    }
8746    if let Some(ref local_var_str) = mtu__empty {
8747        local_var_req_builder =
8748            local_var_req_builder.query(&[("mtu__empty", &local_var_str.to_string())]);
8749    }
8750    if let Some(ref local_var_str) = mtu__gt {
8751        local_var_req_builder = match "multi" {
8752            "multi" => local_var_req_builder.query(
8753                &local_var_str
8754                    .into_iter()
8755                    .map(|p| ("mtu__gt".to_owned(), p.to_string()))
8756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8757            ),
8758            _ => local_var_req_builder.query(&[(
8759                "mtu__gt",
8760                &local_var_str
8761                    .into_iter()
8762                    .map(|p| p.to_string())
8763                    .collect::<Vec<String>>()
8764                    .join(",")
8765                    .to_string(),
8766            )]),
8767        };
8768    }
8769    if let Some(ref local_var_str) = mtu__gte {
8770        local_var_req_builder = match "multi" {
8771            "multi" => local_var_req_builder.query(
8772                &local_var_str
8773                    .into_iter()
8774                    .map(|p| ("mtu__gte".to_owned(), p.to_string()))
8775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8776            ),
8777            _ => local_var_req_builder.query(&[(
8778                "mtu__gte",
8779                &local_var_str
8780                    .into_iter()
8781                    .map(|p| p.to_string())
8782                    .collect::<Vec<String>>()
8783                    .join(",")
8784                    .to_string(),
8785            )]),
8786        };
8787    }
8788    if let Some(ref local_var_str) = mtu__lt {
8789        local_var_req_builder = match "multi" {
8790            "multi" => local_var_req_builder.query(
8791                &local_var_str
8792                    .into_iter()
8793                    .map(|p| ("mtu__lt".to_owned(), p.to_string()))
8794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8795            ),
8796            _ => local_var_req_builder.query(&[(
8797                "mtu__lt",
8798                &local_var_str
8799                    .into_iter()
8800                    .map(|p| p.to_string())
8801                    .collect::<Vec<String>>()
8802                    .join(",")
8803                    .to_string(),
8804            )]),
8805        };
8806    }
8807    if let Some(ref local_var_str) = mtu__lte {
8808        local_var_req_builder = match "multi" {
8809            "multi" => local_var_req_builder.query(
8810                &local_var_str
8811                    .into_iter()
8812                    .map(|p| ("mtu__lte".to_owned(), p.to_string()))
8813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8814            ),
8815            _ => local_var_req_builder.query(&[(
8816                "mtu__lte",
8817                &local_var_str
8818                    .into_iter()
8819                    .map(|p| p.to_string())
8820                    .collect::<Vec<String>>()
8821                    .join(",")
8822                    .to_string(),
8823            )]),
8824        };
8825    }
8826    if let Some(ref local_var_str) = mtu__n {
8827        local_var_req_builder = match "multi" {
8828            "multi" => local_var_req_builder.query(
8829                &local_var_str
8830                    .into_iter()
8831                    .map(|p| ("mtu__n".to_owned(), p.to_string()))
8832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8833            ),
8834            _ => local_var_req_builder.query(&[(
8835                "mtu__n",
8836                &local_var_str
8837                    .into_iter()
8838                    .map(|p| p.to_string())
8839                    .collect::<Vec<String>>()
8840                    .join(",")
8841                    .to_string(),
8842            )]),
8843        };
8844    }
8845    if let Some(ref local_var_str) = name {
8846        local_var_req_builder = match "multi" {
8847            "multi" => local_var_req_builder.query(
8848                &local_var_str
8849                    .into_iter()
8850                    .map(|p| ("name".to_owned(), p.to_string()))
8851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8852            ),
8853            _ => local_var_req_builder.query(&[(
8854                "name",
8855                &local_var_str
8856                    .into_iter()
8857                    .map(|p| p.to_string())
8858                    .collect::<Vec<String>>()
8859                    .join(",")
8860                    .to_string(),
8861            )]),
8862        };
8863    }
8864    if let Some(ref local_var_str) = name__empty {
8865        local_var_req_builder =
8866            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8867    }
8868    if let Some(ref local_var_str) = name__ic {
8869        local_var_req_builder = match "multi" {
8870            "multi" => local_var_req_builder.query(
8871                &local_var_str
8872                    .into_iter()
8873                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8875            ),
8876            _ => local_var_req_builder.query(&[(
8877                "name__ic",
8878                &local_var_str
8879                    .into_iter()
8880                    .map(|p| p.to_string())
8881                    .collect::<Vec<String>>()
8882                    .join(",")
8883                    .to_string(),
8884            )]),
8885        };
8886    }
8887    if let Some(ref local_var_str) = name__ie {
8888        local_var_req_builder = match "multi" {
8889            "multi" => local_var_req_builder.query(
8890                &local_var_str
8891                    .into_iter()
8892                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8894            ),
8895            _ => local_var_req_builder.query(&[(
8896                "name__ie",
8897                &local_var_str
8898                    .into_iter()
8899                    .map(|p| p.to_string())
8900                    .collect::<Vec<String>>()
8901                    .join(",")
8902                    .to_string(),
8903            )]),
8904        };
8905    }
8906    if let Some(ref local_var_str) = name__iew {
8907        local_var_req_builder = match "multi" {
8908            "multi" => local_var_req_builder.query(
8909                &local_var_str
8910                    .into_iter()
8911                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8913            ),
8914            _ => local_var_req_builder.query(&[(
8915                "name__iew",
8916                &local_var_str
8917                    .into_iter()
8918                    .map(|p| p.to_string())
8919                    .collect::<Vec<String>>()
8920                    .join(",")
8921                    .to_string(),
8922            )]),
8923        };
8924    }
8925    if let Some(ref local_var_str) = name__iregex {
8926        local_var_req_builder = match "multi" {
8927            "multi" => local_var_req_builder.query(
8928                &local_var_str
8929                    .into_iter()
8930                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
8931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8932            ),
8933            _ => local_var_req_builder.query(&[(
8934                "name__iregex",
8935                &local_var_str
8936                    .into_iter()
8937                    .map(|p| p.to_string())
8938                    .collect::<Vec<String>>()
8939                    .join(",")
8940                    .to_string(),
8941            )]),
8942        };
8943    }
8944    if let Some(ref local_var_str) = name__isw {
8945        local_var_req_builder = match "multi" {
8946            "multi" => local_var_req_builder.query(
8947                &local_var_str
8948                    .into_iter()
8949                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8951            ),
8952            _ => local_var_req_builder.query(&[(
8953                "name__isw",
8954                &local_var_str
8955                    .into_iter()
8956                    .map(|p| p.to_string())
8957                    .collect::<Vec<String>>()
8958                    .join(",")
8959                    .to_string(),
8960            )]),
8961        };
8962    }
8963    if let Some(ref local_var_str) = name__n {
8964        local_var_req_builder = match "multi" {
8965            "multi" => local_var_req_builder.query(
8966                &local_var_str
8967                    .into_iter()
8968                    .map(|p| ("name__n".to_owned(), p.to_string()))
8969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8970            ),
8971            _ => local_var_req_builder.query(&[(
8972                "name__n",
8973                &local_var_str
8974                    .into_iter()
8975                    .map(|p| p.to_string())
8976                    .collect::<Vec<String>>()
8977                    .join(",")
8978                    .to_string(),
8979            )]),
8980        };
8981    }
8982    if let Some(ref local_var_str) = name__nic {
8983        local_var_req_builder = match "multi" {
8984            "multi" => local_var_req_builder.query(
8985                &local_var_str
8986                    .into_iter()
8987                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8989            ),
8990            _ => local_var_req_builder.query(&[(
8991                "name__nic",
8992                &local_var_str
8993                    .into_iter()
8994                    .map(|p| p.to_string())
8995                    .collect::<Vec<String>>()
8996                    .join(",")
8997                    .to_string(),
8998            )]),
8999        };
9000    }
9001    if let Some(ref local_var_str) = name__nie {
9002        local_var_req_builder = match "multi" {
9003            "multi" => local_var_req_builder.query(
9004                &local_var_str
9005                    .into_iter()
9006                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9008            ),
9009            _ => local_var_req_builder.query(&[(
9010                "name__nie",
9011                &local_var_str
9012                    .into_iter()
9013                    .map(|p| p.to_string())
9014                    .collect::<Vec<String>>()
9015                    .join(",")
9016                    .to_string(),
9017            )]),
9018        };
9019    }
9020    if let Some(ref local_var_str) = name__niew {
9021        local_var_req_builder = match "multi" {
9022            "multi" => local_var_req_builder.query(
9023                &local_var_str
9024                    .into_iter()
9025                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9027            ),
9028            _ => local_var_req_builder.query(&[(
9029                "name__niew",
9030                &local_var_str
9031                    .into_iter()
9032                    .map(|p| p.to_string())
9033                    .collect::<Vec<String>>()
9034                    .join(",")
9035                    .to_string(),
9036            )]),
9037        };
9038    }
9039    if let Some(ref local_var_str) = name__nisw {
9040        local_var_req_builder = match "multi" {
9041            "multi" => local_var_req_builder.query(
9042                &local_var_str
9043                    .into_iter()
9044                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9046            ),
9047            _ => local_var_req_builder.query(&[(
9048                "name__nisw",
9049                &local_var_str
9050                    .into_iter()
9051                    .map(|p| p.to_string())
9052                    .collect::<Vec<String>>()
9053                    .join(",")
9054                    .to_string(),
9055            )]),
9056        };
9057    }
9058    if let Some(ref local_var_str) = name__regex {
9059        local_var_req_builder = match "multi" {
9060            "multi" => local_var_req_builder.query(
9061                &local_var_str
9062                    .into_iter()
9063                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9065            ),
9066            _ => local_var_req_builder.query(&[(
9067                "name__regex",
9068                &local_var_str
9069                    .into_iter()
9070                    .map(|p| p.to_string())
9071                    .collect::<Vec<String>>()
9072                    .join(",")
9073                    .to_string(),
9074            )]),
9075        };
9076    }
9077    if let Some(ref local_var_str) = offset {
9078        local_var_req_builder =
9079            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9080    }
9081    if let Some(ref local_var_str) = ordering {
9082        local_var_req_builder =
9083            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9084    }
9085    if let Some(ref local_var_str) = owner {
9086        local_var_req_builder = match "multi" {
9087            "multi" => local_var_req_builder.query(
9088                &local_var_str
9089                    .into_iter()
9090                    .map(|p| ("owner".to_owned(), p.to_string()))
9091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9092            ),
9093            _ => local_var_req_builder.query(&[(
9094                "owner",
9095                &local_var_str
9096                    .into_iter()
9097                    .map(|p| p.to_string())
9098                    .collect::<Vec<String>>()
9099                    .join(",")
9100                    .to_string(),
9101            )]),
9102        };
9103    }
9104    if let Some(ref local_var_str) = owner__n {
9105        local_var_req_builder = match "multi" {
9106            "multi" => local_var_req_builder.query(
9107                &local_var_str
9108                    .into_iter()
9109                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9111            ),
9112            _ => local_var_req_builder.query(&[(
9113                "owner__n",
9114                &local_var_str
9115                    .into_iter()
9116                    .map(|p| p.to_string())
9117                    .collect::<Vec<String>>()
9118                    .join(",")
9119                    .to_string(),
9120            )]),
9121        };
9122    }
9123    if let Some(ref local_var_str) = owner_group {
9124        local_var_req_builder = match "multi" {
9125            "multi" => local_var_req_builder.query(
9126                &local_var_str
9127                    .into_iter()
9128                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9130            ),
9131            _ => local_var_req_builder.query(&[(
9132                "owner_group",
9133                &local_var_str
9134                    .into_iter()
9135                    .map(|p| p.to_string())
9136                    .collect::<Vec<String>>()
9137                    .join(",")
9138                    .to_string(),
9139            )]),
9140        };
9141    }
9142    if let Some(ref local_var_str) = owner_group__n {
9143        local_var_req_builder = match "multi" {
9144            "multi" => local_var_req_builder.query(
9145                &local_var_str
9146                    .into_iter()
9147                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
9148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9149            ),
9150            _ => local_var_req_builder.query(&[(
9151                "owner_group__n",
9152                &local_var_str
9153                    .into_iter()
9154                    .map(|p| p.to_string())
9155                    .collect::<Vec<String>>()
9156                    .join(",")
9157                    .to_string(),
9158            )]),
9159        };
9160    }
9161    if let Some(ref local_var_str) = owner_group_id {
9162        local_var_req_builder = match "multi" {
9163            "multi" => local_var_req_builder.query(
9164                &local_var_str
9165                    .into_iter()
9166                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9168            ),
9169            _ => local_var_req_builder.query(&[(
9170                "owner_group_id",
9171                &local_var_str
9172                    .into_iter()
9173                    .map(|p| p.to_string())
9174                    .collect::<Vec<String>>()
9175                    .join(",")
9176                    .to_string(),
9177            )]),
9178        };
9179    }
9180    if let Some(ref local_var_str) = owner_group_id__n {
9181        local_var_req_builder = match "multi" {
9182            "multi" => local_var_req_builder.query(
9183                &local_var_str
9184                    .into_iter()
9185                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9187            ),
9188            _ => local_var_req_builder.query(&[(
9189                "owner_group_id__n",
9190                &local_var_str
9191                    .into_iter()
9192                    .map(|p| p.to_string())
9193                    .collect::<Vec<String>>()
9194                    .join(",")
9195                    .to_string(),
9196            )]),
9197        };
9198    }
9199    if let Some(ref local_var_str) = owner_id {
9200        local_var_req_builder = match "multi" {
9201            "multi" => local_var_req_builder.query(
9202                &local_var_str
9203                    .into_iter()
9204                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9206            ),
9207            _ => local_var_req_builder.query(&[(
9208                "owner_id",
9209                &local_var_str
9210                    .into_iter()
9211                    .map(|p| p.to_string())
9212                    .collect::<Vec<String>>()
9213                    .join(",")
9214                    .to_string(),
9215            )]),
9216        };
9217    }
9218    if let Some(ref local_var_str) = owner_id__n {
9219        local_var_req_builder = match "multi" {
9220            "multi" => local_var_req_builder.query(
9221                &local_var_str
9222                    .into_iter()
9223                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9225            ),
9226            _ => local_var_req_builder.query(&[(
9227                "owner_id__n",
9228                &local_var_str
9229                    .into_iter()
9230                    .map(|p| p.to_string())
9231                    .collect::<Vec<String>>()
9232                    .join(",")
9233                    .to_string(),
9234            )]),
9235        };
9236    }
9237    if let Some(ref local_var_str) = parent_id {
9238        local_var_req_builder = match "multi" {
9239            "multi" => local_var_req_builder.query(
9240                &local_var_str
9241                    .into_iter()
9242                    .map(|p| ("parent_id".to_owned(), p.to_string()))
9243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9244            ),
9245            _ => local_var_req_builder.query(&[(
9246                "parent_id",
9247                &local_var_str
9248                    .into_iter()
9249                    .map(|p| p.to_string())
9250                    .collect::<Vec<String>>()
9251                    .join(",")
9252                    .to_string(),
9253            )]),
9254        };
9255    }
9256    if let Some(ref local_var_str) = parent_id__n {
9257        local_var_req_builder = match "multi" {
9258            "multi" => local_var_req_builder.query(
9259                &local_var_str
9260                    .into_iter()
9261                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
9262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9263            ),
9264            _ => local_var_req_builder.query(&[(
9265                "parent_id__n",
9266                &local_var_str
9267                    .into_iter()
9268                    .map(|p| p.to_string())
9269                    .collect::<Vec<String>>()
9270                    .join(",")
9271                    .to_string(),
9272            )]),
9273        };
9274    }
9275    if let Some(ref local_var_str) = primary_mac_address {
9276        local_var_req_builder = match "multi" {
9277            "multi" => local_var_req_builder.query(
9278                &local_var_str
9279                    .into_iter()
9280                    .map(|p| ("primary_mac_address".to_owned(), p.to_string()))
9281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9282            ),
9283            _ => local_var_req_builder.query(&[(
9284                "primary_mac_address",
9285                &local_var_str
9286                    .into_iter()
9287                    .map(|p| p.to_string())
9288                    .collect::<Vec<String>>()
9289                    .join(",")
9290                    .to_string(),
9291            )]),
9292        };
9293    }
9294    if let Some(ref local_var_str) = primary_mac_address__n {
9295        local_var_req_builder = match "multi" {
9296            "multi" => local_var_req_builder.query(
9297                &local_var_str
9298                    .into_iter()
9299                    .map(|p| ("primary_mac_address__n".to_owned(), p.to_string()))
9300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9301            ),
9302            _ => local_var_req_builder.query(&[(
9303                "primary_mac_address__n",
9304                &local_var_str
9305                    .into_iter()
9306                    .map(|p| p.to_string())
9307                    .collect::<Vec<String>>()
9308                    .join(",")
9309                    .to_string(),
9310            )]),
9311        };
9312    }
9313    if let Some(ref local_var_str) = primary_mac_address_id {
9314        local_var_req_builder = match "multi" {
9315            "multi" => local_var_req_builder.query(
9316                &local_var_str
9317                    .into_iter()
9318                    .map(|p| ("primary_mac_address_id".to_owned(), p.to_string()))
9319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9320            ),
9321            _ => local_var_req_builder.query(&[(
9322                "primary_mac_address_id",
9323                &local_var_str
9324                    .into_iter()
9325                    .map(|p| p.to_string())
9326                    .collect::<Vec<String>>()
9327                    .join(",")
9328                    .to_string(),
9329            )]),
9330        };
9331    }
9332    if let Some(ref local_var_str) = primary_mac_address_id__n {
9333        local_var_req_builder = match "multi" {
9334            "multi" => local_var_req_builder.query(
9335                &local_var_str
9336                    .into_iter()
9337                    .map(|p| ("primary_mac_address_id__n".to_owned(), p.to_string()))
9338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9339            ),
9340            _ => local_var_req_builder.query(&[(
9341                "primary_mac_address_id__n",
9342                &local_var_str
9343                    .into_iter()
9344                    .map(|p| p.to_string())
9345                    .collect::<Vec<String>>()
9346                    .join(",")
9347                    .to_string(),
9348            )]),
9349        };
9350    }
9351    if let Some(ref local_var_str) = q {
9352        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9353    }
9354    if let Some(ref local_var_str) = tag {
9355        local_var_req_builder = match "multi" {
9356            "multi" => local_var_req_builder.query(
9357                &local_var_str
9358                    .into_iter()
9359                    .map(|p| ("tag".to_owned(), p.to_string()))
9360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9361            ),
9362            _ => local_var_req_builder.query(&[(
9363                "tag",
9364                &local_var_str
9365                    .into_iter()
9366                    .map(|p| p.to_string())
9367                    .collect::<Vec<String>>()
9368                    .join(",")
9369                    .to_string(),
9370            )]),
9371        };
9372    }
9373    if let Some(ref local_var_str) = tag__n {
9374        local_var_req_builder = match "multi" {
9375            "multi" => local_var_req_builder.query(
9376                &local_var_str
9377                    .into_iter()
9378                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9380            ),
9381            _ => local_var_req_builder.query(&[(
9382                "tag__n",
9383                &local_var_str
9384                    .into_iter()
9385                    .map(|p| p.to_string())
9386                    .collect::<Vec<String>>()
9387                    .join(",")
9388                    .to_string(),
9389            )]),
9390        };
9391    }
9392    if let Some(ref local_var_str) = tag_id {
9393        local_var_req_builder = match "multi" {
9394            "multi" => local_var_req_builder.query(
9395                &local_var_str
9396                    .into_iter()
9397                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9399            ),
9400            _ => local_var_req_builder.query(&[(
9401                "tag_id",
9402                &local_var_str
9403                    .into_iter()
9404                    .map(|p| p.to_string())
9405                    .collect::<Vec<String>>()
9406                    .join(",")
9407                    .to_string(),
9408            )]),
9409        };
9410    }
9411    if let Some(ref local_var_str) = tag_id__n {
9412        local_var_req_builder = match "multi" {
9413            "multi" => local_var_req_builder.query(
9414                &local_var_str
9415                    .into_iter()
9416                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9418            ),
9419            _ => local_var_req_builder.query(&[(
9420                "tag_id__n",
9421                &local_var_str
9422                    .into_iter()
9423                    .map(|p| p.to_string())
9424                    .collect::<Vec<String>>()
9425                    .join(",")
9426                    .to_string(),
9427            )]),
9428        };
9429    }
9430    if let Some(ref local_var_str) = updated_by_request {
9431        local_var_req_builder =
9432            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9433    }
9434    if let Some(ref local_var_str) = virtual_machine {
9435        local_var_req_builder = match "multi" {
9436            "multi" => local_var_req_builder.query(
9437                &local_var_str
9438                    .into_iter()
9439                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
9440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9441            ),
9442            _ => local_var_req_builder.query(&[(
9443                "virtual_machine",
9444                &local_var_str
9445                    .into_iter()
9446                    .map(|p| p.to_string())
9447                    .collect::<Vec<String>>()
9448                    .join(",")
9449                    .to_string(),
9450            )]),
9451        };
9452    }
9453    if let Some(ref local_var_str) = virtual_machine__n {
9454        local_var_req_builder = match "multi" {
9455            "multi" => local_var_req_builder.query(
9456                &local_var_str
9457                    .into_iter()
9458                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
9459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9460            ),
9461            _ => local_var_req_builder.query(&[(
9462                "virtual_machine__n",
9463                &local_var_str
9464                    .into_iter()
9465                    .map(|p| p.to_string())
9466                    .collect::<Vec<String>>()
9467                    .join(",")
9468                    .to_string(),
9469            )]),
9470        };
9471    }
9472    if let Some(ref local_var_str) = virtual_machine_id {
9473        local_var_req_builder = match "multi" {
9474            "multi" => local_var_req_builder.query(
9475                &local_var_str
9476                    .into_iter()
9477                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
9478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9479            ),
9480            _ => local_var_req_builder.query(&[(
9481                "virtual_machine_id",
9482                &local_var_str
9483                    .into_iter()
9484                    .map(|p| p.to_string())
9485                    .collect::<Vec<String>>()
9486                    .join(",")
9487                    .to_string(),
9488            )]),
9489        };
9490    }
9491    if let Some(ref local_var_str) = virtual_machine_id__n {
9492        local_var_req_builder = match "multi" {
9493            "multi" => local_var_req_builder.query(
9494                &local_var_str
9495                    .into_iter()
9496                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
9497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9498            ),
9499            _ => local_var_req_builder.query(&[(
9500                "virtual_machine_id__n",
9501                &local_var_str
9502                    .into_iter()
9503                    .map(|p| p.to_string())
9504                    .collect::<Vec<String>>()
9505                    .join(",")
9506                    .to_string(),
9507            )]),
9508        };
9509    }
9510    if let Some(ref local_var_str) = vlan {
9511        local_var_req_builder =
9512            local_var_req_builder.query(&[("vlan", &local_var_str.to_string())]);
9513    }
9514    if let Some(ref local_var_str) = vlan_id {
9515        local_var_req_builder =
9516            local_var_req_builder.query(&[("vlan_id", &local_var_str.to_string())]);
9517    }
9518    if let Some(ref local_var_str) = vlan_translation_policy {
9519        local_var_req_builder = match "multi" {
9520            "multi" => local_var_req_builder.query(
9521                &local_var_str
9522                    .into_iter()
9523                    .map(|p| ("vlan_translation_policy".to_owned(), p.to_string()))
9524                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9525            ),
9526            _ => local_var_req_builder.query(&[(
9527                "vlan_translation_policy",
9528                &local_var_str
9529                    .into_iter()
9530                    .map(|p| p.to_string())
9531                    .collect::<Vec<String>>()
9532                    .join(",")
9533                    .to_string(),
9534            )]),
9535        };
9536    }
9537    if let Some(ref local_var_str) = vlan_translation_policy__n {
9538        local_var_req_builder = match "multi" {
9539            "multi" => local_var_req_builder.query(
9540                &local_var_str
9541                    .into_iter()
9542                    .map(|p| ("vlan_translation_policy__n".to_owned(), p.to_string()))
9543                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9544            ),
9545            _ => local_var_req_builder.query(&[(
9546                "vlan_translation_policy__n",
9547                &local_var_str
9548                    .into_iter()
9549                    .map(|p| p.to_string())
9550                    .collect::<Vec<String>>()
9551                    .join(",")
9552                    .to_string(),
9553            )]),
9554        };
9555    }
9556    if let Some(ref local_var_str) = vlan_translation_policy_id {
9557        local_var_req_builder = match "multi" {
9558            "multi" => local_var_req_builder.query(
9559                &local_var_str
9560                    .into_iter()
9561                    .map(|p| ("vlan_translation_policy_id".to_owned(), p.to_string()))
9562                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9563            ),
9564            _ => local_var_req_builder.query(&[(
9565                "vlan_translation_policy_id",
9566                &local_var_str
9567                    .into_iter()
9568                    .map(|p| p.to_string())
9569                    .collect::<Vec<String>>()
9570                    .join(",")
9571                    .to_string(),
9572            )]),
9573        };
9574    }
9575    if let Some(ref local_var_str) = vlan_translation_policy_id__n {
9576        local_var_req_builder = match "multi" {
9577            "multi" => local_var_req_builder.query(
9578                &local_var_str
9579                    .into_iter()
9580                    .map(|p| ("vlan_translation_policy_id__n".to_owned(), p.to_string()))
9581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9582            ),
9583            _ => local_var_req_builder.query(&[(
9584                "vlan_translation_policy_id__n",
9585                &local_var_str
9586                    .into_iter()
9587                    .map(|p| p.to_string())
9588                    .collect::<Vec<String>>()
9589                    .join(",")
9590                    .to_string(),
9591            )]),
9592        };
9593    }
9594    if let Some(ref local_var_str) = vrf {
9595        local_var_req_builder = match "multi" {
9596            "multi" => local_var_req_builder.query(
9597                &local_var_str
9598                    .into_iter()
9599                    .map(|p| ("vrf".to_owned(), p.to_string()))
9600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9601            ),
9602            _ => local_var_req_builder.query(&[(
9603                "vrf",
9604                &local_var_str
9605                    .into_iter()
9606                    .map(|p| p.to_string())
9607                    .collect::<Vec<String>>()
9608                    .join(",")
9609                    .to_string(),
9610            )]),
9611        };
9612    }
9613    if let Some(ref local_var_str) = vrf__n {
9614        local_var_req_builder = match "multi" {
9615            "multi" => local_var_req_builder.query(
9616                &local_var_str
9617                    .into_iter()
9618                    .map(|p| ("vrf__n".to_owned(), p.to_string()))
9619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9620            ),
9621            _ => local_var_req_builder.query(&[(
9622                "vrf__n",
9623                &local_var_str
9624                    .into_iter()
9625                    .map(|p| p.to_string())
9626                    .collect::<Vec<String>>()
9627                    .join(",")
9628                    .to_string(),
9629            )]),
9630        };
9631    }
9632    if let Some(ref local_var_str) = vrf_id {
9633        local_var_req_builder = match "multi" {
9634            "multi" => local_var_req_builder.query(
9635                &local_var_str
9636                    .into_iter()
9637                    .map(|p| ("vrf_id".to_owned(), p.to_string()))
9638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9639            ),
9640            _ => local_var_req_builder.query(&[(
9641                "vrf_id",
9642                &local_var_str
9643                    .into_iter()
9644                    .map(|p| p.to_string())
9645                    .collect::<Vec<String>>()
9646                    .join(",")
9647                    .to_string(),
9648            )]),
9649        };
9650    }
9651    if let Some(ref local_var_str) = vrf_id__n {
9652        local_var_req_builder = match "multi" {
9653            "multi" => local_var_req_builder.query(
9654                &local_var_str
9655                    .into_iter()
9656                    .map(|p| ("vrf_id__n".to_owned(), p.to_string()))
9657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9658            ),
9659            _ => local_var_req_builder.query(&[(
9660                "vrf_id__n",
9661                &local_var_str
9662                    .into_iter()
9663                    .map(|p| p.to_string())
9664                    .collect::<Vec<String>>()
9665                    .join(",")
9666                    .to_string(),
9667            )]),
9668        };
9669    }
9670    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9671        local_var_req_builder =
9672            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9673    }
9674    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9675        let local_var_key = local_var_apikey.key.clone();
9676        let local_var_value = match local_var_apikey.prefix {
9677            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9678            None => local_var_key,
9679        };
9680        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9681    };
9682
9683    let local_var_req = local_var_req_builder.build()?;
9684    let local_var_resp = local_var_client.execute(local_var_req).await?;
9685
9686    let local_var_status = local_var_resp.status();
9687    let local_var_content = local_var_resp.text().await?;
9688
9689    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9690        serde_json::from_str(&local_var_content).map_err(Error::from)
9691    } else {
9692        let local_var_entity: Option<VirtualizationInterfacesListError> =
9693            serde_json::from_str(&local_var_content).ok();
9694        let local_var_error = ResponseContent {
9695            status: local_var_status,
9696            content: local_var_content,
9697            entity: local_var_entity,
9698        };
9699        Err(Error::ResponseError(local_var_error))
9700    }
9701}
9702
9703/// Patch a interface object.
9704pub async fn virtualization_interfaces_partial_update(
9705    configuration: &configuration::Configuration,
9706    id: i32,
9707    patched_writable_vm_interface_request: Option<crate::models::PatchedWritableVmInterfaceRequest>,
9708) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesPartialUpdateError>> {
9709    let local_var_configuration = configuration;
9710
9711    let local_var_client = &local_var_configuration.client;
9712
9713    let local_var_uri_str = format!(
9714        "{}/api/virtualization/interfaces/{id}/",
9715        local_var_configuration.base_path,
9716        id = id
9717    );
9718    let mut local_var_req_builder =
9719        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9720
9721    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9722        local_var_req_builder =
9723            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9724    }
9725    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9726        let local_var_key = local_var_apikey.key.clone();
9727        let local_var_value = match local_var_apikey.prefix {
9728            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9729            None => local_var_key,
9730        };
9731        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9732    };
9733    local_var_req_builder = local_var_req_builder.json(&patched_writable_vm_interface_request);
9734
9735    let local_var_req = local_var_req_builder.build()?;
9736    let local_var_resp = local_var_client.execute(local_var_req).await?;
9737
9738    let local_var_status = local_var_resp.status();
9739    let local_var_content = local_var_resp.text().await?;
9740
9741    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9742        serde_json::from_str(&local_var_content).map_err(Error::from)
9743    } else {
9744        let local_var_entity: Option<VirtualizationInterfacesPartialUpdateError> =
9745            serde_json::from_str(&local_var_content).ok();
9746        let local_var_error = ResponseContent {
9747            status: local_var_status,
9748            content: local_var_content,
9749            entity: local_var_entity,
9750        };
9751        Err(Error::ResponseError(local_var_error))
9752    }
9753}
9754
9755/// Get a interface object.
9756pub async fn virtualization_interfaces_retrieve(
9757    configuration: &configuration::Configuration,
9758    id: i32,
9759) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesRetrieveError>> {
9760    let local_var_configuration = configuration;
9761
9762    let local_var_client = &local_var_configuration.client;
9763
9764    let local_var_uri_str = format!(
9765        "{}/api/virtualization/interfaces/{id}/",
9766        local_var_configuration.base_path,
9767        id = id
9768    );
9769    let mut local_var_req_builder =
9770        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9771
9772    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9773        local_var_req_builder =
9774            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9775    }
9776    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9777        let local_var_key = local_var_apikey.key.clone();
9778        let local_var_value = match local_var_apikey.prefix {
9779            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9780            None => local_var_key,
9781        };
9782        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9783    };
9784
9785    let local_var_req = local_var_req_builder.build()?;
9786    let local_var_resp = local_var_client.execute(local_var_req).await?;
9787
9788    let local_var_status = local_var_resp.status();
9789    let local_var_content = local_var_resp.text().await?;
9790
9791    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9792        serde_json::from_str(&local_var_content).map_err(Error::from)
9793    } else {
9794        let local_var_entity: Option<VirtualizationInterfacesRetrieveError> =
9795            serde_json::from_str(&local_var_content).ok();
9796        let local_var_error = ResponseContent {
9797            status: local_var_status,
9798            content: local_var_content,
9799            entity: local_var_entity,
9800        };
9801        Err(Error::ResponseError(local_var_error))
9802    }
9803}
9804
9805/// Put a interface object.
9806pub async fn virtualization_interfaces_update(
9807    configuration: &configuration::Configuration,
9808    id: i32,
9809    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
9810) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesUpdateError>> {
9811    let local_var_configuration = configuration;
9812
9813    let local_var_client = &local_var_configuration.client;
9814
9815    let local_var_uri_str = format!(
9816        "{}/api/virtualization/interfaces/{id}/",
9817        local_var_configuration.base_path,
9818        id = id
9819    );
9820    let mut local_var_req_builder =
9821        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9822
9823    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9824        local_var_req_builder =
9825            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9826    }
9827    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9828        let local_var_key = local_var_apikey.key.clone();
9829        let local_var_value = match local_var_apikey.prefix {
9830            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9831            None => local_var_key,
9832        };
9833        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9834    };
9835    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
9836
9837    let local_var_req = local_var_req_builder.build()?;
9838    let local_var_resp = local_var_client.execute(local_var_req).await?;
9839
9840    let local_var_status = local_var_resp.status();
9841    let local_var_content = local_var_resp.text().await?;
9842
9843    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9844        serde_json::from_str(&local_var_content).map_err(Error::from)
9845    } else {
9846        let local_var_entity: Option<VirtualizationInterfacesUpdateError> =
9847            serde_json::from_str(&local_var_content).ok();
9848        let local_var_error = ResponseContent {
9849            status: local_var_status,
9850            content: local_var_content,
9851            entity: local_var_entity,
9852        };
9853        Err(Error::ResponseError(local_var_error))
9854    }
9855}
9856
9857/// Delete a list of virtual disk objects.
9858pub async fn virtualization_virtual_disks_bulk_destroy(
9859    configuration: &configuration::Configuration,
9860    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9861) -> Result<(), Error<VirtualizationVirtualDisksBulkDestroyError>> {
9862    let local_var_configuration = configuration;
9863
9864    let local_var_client = &local_var_configuration.client;
9865
9866    let local_var_uri_str = format!(
9867        "{}/api/virtualization/virtual-disks/",
9868        local_var_configuration.base_path
9869    );
9870    let mut local_var_req_builder =
9871        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9872
9873    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9874        local_var_req_builder =
9875            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9876    }
9877    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9878        let local_var_key = local_var_apikey.key.clone();
9879        let local_var_value = match local_var_apikey.prefix {
9880            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9881            None => local_var_key,
9882        };
9883        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9884    };
9885    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9886
9887    let local_var_req = local_var_req_builder.build()?;
9888    let local_var_resp = local_var_client.execute(local_var_req).await?;
9889
9890    let local_var_status = local_var_resp.status();
9891    let local_var_content = local_var_resp.text().await?;
9892
9893    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9894        Ok(())
9895    } else {
9896        let local_var_entity: Option<VirtualizationVirtualDisksBulkDestroyError> =
9897            serde_json::from_str(&local_var_content).ok();
9898        let local_var_error = ResponseContent {
9899            status: local_var_status,
9900            content: local_var_content,
9901            entity: local_var_entity,
9902        };
9903        Err(Error::ResponseError(local_var_error))
9904    }
9905}
9906
9907/// Patch a list of virtual disk objects.
9908pub async fn virtualization_virtual_disks_bulk_partial_update(
9909    configuration: &configuration::Configuration,
9910    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9911) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkPartialUpdateError>>
9912{
9913    let local_var_configuration = configuration;
9914
9915    let local_var_client = &local_var_configuration.client;
9916
9917    let local_var_uri_str = format!(
9918        "{}/api/virtualization/virtual-disks/",
9919        local_var_configuration.base_path
9920    );
9921    let mut local_var_req_builder =
9922        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9923
9924    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9925        local_var_req_builder =
9926            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9927    }
9928    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9929        let local_var_key = local_var_apikey.key.clone();
9930        let local_var_value = match local_var_apikey.prefix {
9931            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9932            None => local_var_key,
9933        };
9934        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9935    };
9936    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9937
9938    let local_var_req = local_var_req_builder.build()?;
9939    let local_var_resp = local_var_client.execute(local_var_req).await?;
9940
9941    let local_var_status = local_var_resp.status();
9942    let local_var_content = local_var_resp.text().await?;
9943
9944    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9945        serde_json::from_str(&local_var_content).map_err(Error::from)
9946    } else {
9947        let local_var_entity: Option<VirtualizationVirtualDisksBulkPartialUpdateError> =
9948            serde_json::from_str(&local_var_content).ok();
9949        let local_var_error = ResponseContent {
9950            status: local_var_status,
9951            content: local_var_content,
9952            entity: local_var_entity,
9953        };
9954        Err(Error::ResponseError(local_var_error))
9955    }
9956}
9957
9958/// Put a list of virtual disk objects.
9959pub async fn virtualization_virtual_disks_bulk_update(
9960    configuration: &configuration::Configuration,
9961    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9962) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkUpdateError>> {
9963    let local_var_configuration = configuration;
9964
9965    let local_var_client = &local_var_configuration.client;
9966
9967    let local_var_uri_str = format!(
9968        "{}/api/virtualization/virtual-disks/",
9969        local_var_configuration.base_path
9970    );
9971    let mut local_var_req_builder =
9972        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9973
9974    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9975        local_var_req_builder =
9976            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9977    }
9978    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9979        let local_var_key = local_var_apikey.key.clone();
9980        let local_var_value = match local_var_apikey.prefix {
9981            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9982            None => local_var_key,
9983        };
9984        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9985    };
9986    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9987
9988    let local_var_req = local_var_req_builder.build()?;
9989    let local_var_resp = local_var_client.execute(local_var_req).await?;
9990
9991    let local_var_status = local_var_resp.status();
9992    let local_var_content = local_var_resp.text().await?;
9993
9994    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9995        serde_json::from_str(&local_var_content).map_err(Error::from)
9996    } else {
9997        let local_var_entity: Option<VirtualizationVirtualDisksBulkUpdateError> =
9998            serde_json::from_str(&local_var_content).ok();
9999        let local_var_error = ResponseContent {
10000            status: local_var_status,
10001            content: local_var_content,
10002            entity: local_var_entity,
10003        };
10004        Err(Error::ResponseError(local_var_error))
10005    }
10006}
10007
10008/// Post a list of virtual disk objects.
10009pub async fn virtualization_virtual_disks_create(
10010    configuration: &configuration::Configuration,
10011    virtualization_virtual_disks_create_request: crate::models::VirtualizationVirtualDisksCreateRequest,
10012) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksCreateError>> {
10013    let local_var_configuration = configuration;
10014
10015    let local_var_client = &local_var_configuration.client;
10016
10017    let local_var_uri_str = format!(
10018        "{}/api/virtualization/virtual-disks/",
10019        local_var_configuration.base_path
10020    );
10021    let mut local_var_req_builder =
10022        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10023
10024    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10025        local_var_req_builder =
10026            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10027    }
10028    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10029        let local_var_key = local_var_apikey.key.clone();
10030        let local_var_value = match local_var_apikey.prefix {
10031            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10032            None => local_var_key,
10033        };
10034        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10035    };
10036    local_var_req_builder =
10037        local_var_req_builder.json(&virtualization_virtual_disks_create_request);
10038
10039    let local_var_req = local_var_req_builder.build()?;
10040    let local_var_resp = local_var_client.execute(local_var_req).await?;
10041
10042    let local_var_status = local_var_resp.status();
10043    let local_var_content = local_var_resp.text().await?;
10044
10045    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10046        serde_json::from_str(&local_var_content).map_err(Error::from)
10047    } else {
10048        let local_var_entity: Option<VirtualizationVirtualDisksCreateError> =
10049            serde_json::from_str(&local_var_content).ok();
10050        let local_var_error = ResponseContent {
10051            status: local_var_status,
10052            content: local_var_content,
10053            entity: local_var_entity,
10054        };
10055        Err(Error::ResponseError(local_var_error))
10056    }
10057}
10058
10059/// Delete a virtual disk object.
10060pub async fn virtualization_virtual_disks_destroy(
10061    configuration: &configuration::Configuration,
10062    id: i32,
10063) -> Result<(), Error<VirtualizationVirtualDisksDestroyError>> {
10064    let local_var_configuration = configuration;
10065
10066    let local_var_client = &local_var_configuration.client;
10067
10068    let local_var_uri_str = format!(
10069        "{}/api/virtualization/virtual-disks/{id}/",
10070        local_var_configuration.base_path,
10071        id = id
10072    );
10073    let mut local_var_req_builder =
10074        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10075
10076    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10077        local_var_req_builder =
10078            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10079    }
10080    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10081        let local_var_key = local_var_apikey.key.clone();
10082        let local_var_value = match local_var_apikey.prefix {
10083            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10084            None => local_var_key,
10085        };
10086        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10087    };
10088
10089    let local_var_req = local_var_req_builder.build()?;
10090    let local_var_resp = local_var_client.execute(local_var_req).await?;
10091
10092    let local_var_status = local_var_resp.status();
10093    let local_var_content = local_var_resp.text().await?;
10094
10095    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10096        Ok(())
10097    } else {
10098        let local_var_entity: Option<VirtualizationVirtualDisksDestroyError> =
10099            serde_json::from_str(&local_var_content).ok();
10100        let local_var_error = ResponseContent {
10101            status: local_var_status,
10102            content: local_var_content,
10103            entity: local_var_entity,
10104        };
10105        Err(Error::ResponseError(local_var_error))
10106    }
10107}
10108
10109/// Get a list of virtual disk objects.
10110pub async fn virtualization_virtual_disks_list(
10111    configuration: &configuration::Configuration,
10112    created: Option<Vec<String>>,
10113    created__empty: Option<Vec<String>>,
10114    created__gt: Option<Vec<String>>,
10115    created__gte: Option<Vec<String>>,
10116    created__lt: Option<Vec<String>>,
10117    created__lte: Option<Vec<String>>,
10118    created__n: Option<Vec<String>>,
10119    created_by_request: Option<&str>,
10120    description: Option<Vec<String>>,
10121    description__empty: Option<bool>,
10122    description__ic: Option<Vec<String>>,
10123    description__ie: Option<Vec<String>>,
10124    description__iew: Option<Vec<String>>,
10125    description__iregex: Option<Vec<String>>,
10126    description__isw: Option<Vec<String>>,
10127    description__n: Option<Vec<String>>,
10128    description__nic: Option<Vec<String>>,
10129    description__nie: Option<Vec<String>>,
10130    description__niew: Option<Vec<String>>,
10131    description__nisw: Option<Vec<String>>,
10132    description__regex: Option<Vec<String>>,
10133    id: Option<Vec<i32>>,
10134    id__empty: Option<bool>,
10135    id__gt: Option<Vec<i32>>,
10136    id__gte: Option<Vec<i32>>,
10137    id__lt: Option<Vec<i32>>,
10138    id__lte: Option<Vec<i32>>,
10139    id__n: Option<Vec<i32>>,
10140    last_updated: Option<Vec<String>>,
10141    last_updated__empty: Option<Vec<String>>,
10142    last_updated__gt: Option<Vec<String>>,
10143    last_updated__gte: Option<Vec<String>>,
10144    last_updated__lt: Option<Vec<String>>,
10145    last_updated__lte: Option<Vec<String>>,
10146    last_updated__n: Option<Vec<String>>,
10147    limit: Option<i32>,
10148    modified_by_request: Option<&str>,
10149    name: Option<Vec<String>>,
10150    name__empty: Option<bool>,
10151    name__ic: Option<Vec<String>>,
10152    name__ie: Option<Vec<String>>,
10153    name__iew: Option<Vec<String>>,
10154    name__iregex: Option<Vec<String>>,
10155    name__isw: Option<Vec<String>>,
10156    name__n: Option<Vec<String>>,
10157    name__nic: Option<Vec<String>>,
10158    name__nie: Option<Vec<String>>,
10159    name__niew: Option<Vec<String>>,
10160    name__nisw: Option<Vec<String>>,
10161    name__regex: Option<Vec<String>>,
10162    offset: Option<i32>,
10163    ordering: Option<&str>,
10164    owner: Option<Vec<String>>,
10165    owner__n: Option<Vec<String>>,
10166    owner_group: Option<Vec<String>>,
10167    owner_group__n: Option<Vec<String>>,
10168    owner_group_id: Option<Vec<i32>>,
10169    owner_group_id__n: Option<Vec<i32>>,
10170    owner_id: Option<Vec<i32>>,
10171    owner_id__n: Option<Vec<i32>>,
10172    q: Option<&str>,
10173    size: Option<Vec<i32>>,
10174    size__empty: Option<bool>,
10175    size__gt: Option<Vec<i32>>,
10176    size__gte: Option<Vec<i32>>,
10177    size__lt: Option<Vec<i32>>,
10178    size__lte: Option<Vec<i32>>,
10179    size__n: Option<Vec<i32>>,
10180    tag: Option<Vec<String>>,
10181    tag__n: Option<Vec<String>>,
10182    tag_id: Option<Vec<i32>>,
10183    tag_id__n: Option<Vec<i32>>,
10184    updated_by_request: Option<&str>,
10185    virtual_machine: Option<Vec<String>>,
10186    virtual_machine__n: Option<Vec<String>>,
10187    virtual_machine_id: Option<Vec<i32>>,
10188    virtual_machine_id__n: Option<Vec<i32>>,
10189) -> Result<crate::models::PaginatedVirtualDiskList, Error<VirtualizationVirtualDisksListError>> {
10190    let local_var_configuration = configuration;
10191
10192    let local_var_client = &local_var_configuration.client;
10193
10194    let local_var_uri_str = format!(
10195        "{}/api/virtualization/virtual-disks/",
10196        local_var_configuration.base_path
10197    );
10198    let mut local_var_req_builder =
10199        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10200
10201    if let Some(ref local_var_str) = created {
10202        local_var_req_builder = match "multi" {
10203            "multi" => local_var_req_builder.query(
10204                &local_var_str
10205                    .into_iter()
10206                    .map(|p| ("created".to_owned(), p.to_string()))
10207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10208            ),
10209            _ => local_var_req_builder.query(&[(
10210                "created",
10211                &local_var_str
10212                    .into_iter()
10213                    .map(|p| p.to_string())
10214                    .collect::<Vec<String>>()
10215                    .join(",")
10216                    .to_string(),
10217            )]),
10218        };
10219    }
10220    if let Some(ref local_var_str) = created__empty {
10221        local_var_req_builder = match "multi" {
10222            "multi" => local_var_req_builder.query(
10223                &local_var_str
10224                    .into_iter()
10225                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10227            ),
10228            _ => local_var_req_builder.query(&[(
10229                "created__empty",
10230                &local_var_str
10231                    .into_iter()
10232                    .map(|p| p.to_string())
10233                    .collect::<Vec<String>>()
10234                    .join(",")
10235                    .to_string(),
10236            )]),
10237        };
10238    }
10239    if let Some(ref local_var_str) = created__gt {
10240        local_var_req_builder = match "multi" {
10241            "multi" => local_var_req_builder.query(
10242                &local_var_str
10243                    .into_iter()
10244                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10246            ),
10247            _ => local_var_req_builder.query(&[(
10248                "created__gt",
10249                &local_var_str
10250                    .into_iter()
10251                    .map(|p| p.to_string())
10252                    .collect::<Vec<String>>()
10253                    .join(",")
10254                    .to_string(),
10255            )]),
10256        };
10257    }
10258    if let Some(ref local_var_str) = created__gte {
10259        local_var_req_builder = match "multi" {
10260            "multi" => local_var_req_builder.query(
10261                &local_var_str
10262                    .into_iter()
10263                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10265            ),
10266            _ => local_var_req_builder.query(&[(
10267                "created__gte",
10268                &local_var_str
10269                    .into_iter()
10270                    .map(|p| p.to_string())
10271                    .collect::<Vec<String>>()
10272                    .join(",")
10273                    .to_string(),
10274            )]),
10275        };
10276    }
10277    if let Some(ref local_var_str) = created__lt {
10278        local_var_req_builder = match "multi" {
10279            "multi" => local_var_req_builder.query(
10280                &local_var_str
10281                    .into_iter()
10282                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10284            ),
10285            _ => local_var_req_builder.query(&[(
10286                "created__lt",
10287                &local_var_str
10288                    .into_iter()
10289                    .map(|p| p.to_string())
10290                    .collect::<Vec<String>>()
10291                    .join(",")
10292                    .to_string(),
10293            )]),
10294        };
10295    }
10296    if let Some(ref local_var_str) = created__lte {
10297        local_var_req_builder = match "multi" {
10298            "multi" => local_var_req_builder.query(
10299                &local_var_str
10300                    .into_iter()
10301                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10303            ),
10304            _ => local_var_req_builder.query(&[(
10305                "created__lte",
10306                &local_var_str
10307                    .into_iter()
10308                    .map(|p| p.to_string())
10309                    .collect::<Vec<String>>()
10310                    .join(",")
10311                    .to_string(),
10312            )]),
10313        };
10314    }
10315    if let Some(ref local_var_str) = created__n {
10316        local_var_req_builder = match "multi" {
10317            "multi" => local_var_req_builder.query(
10318                &local_var_str
10319                    .into_iter()
10320                    .map(|p| ("created__n".to_owned(), p.to_string()))
10321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10322            ),
10323            _ => local_var_req_builder.query(&[(
10324                "created__n",
10325                &local_var_str
10326                    .into_iter()
10327                    .map(|p| p.to_string())
10328                    .collect::<Vec<String>>()
10329                    .join(",")
10330                    .to_string(),
10331            )]),
10332        };
10333    }
10334    if let Some(ref local_var_str) = created_by_request {
10335        local_var_req_builder =
10336            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10337    }
10338    if let Some(ref local_var_str) = description {
10339        local_var_req_builder = match "multi" {
10340            "multi" => local_var_req_builder.query(
10341                &local_var_str
10342                    .into_iter()
10343                    .map(|p| ("description".to_owned(), p.to_string()))
10344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10345            ),
10346            _ => local_var_req_builder.query(&[(
10347                "description",
10348                &local_var_str
10349                    .into_iter()
10350                    .map(|p| p.to_string())
10351                    .collect::<Vec<String>>()
10352                    .join(",")
10353                    .to_string(),
10354            )]),
10355        };
10356    }
10357    if let Some(ref local_var_str) = description__empty {
10358        local_var_req_builder =
10359            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10360    }
10361    if let Some(ref local_var_str) = description__ic {
10362        local_var_req_builder = match "multi" {
10363            "multi" => local_var_req_builder.query(
10364                &local_var_str
10365                    .into_iter()
10366                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10368            ),
10369            _ => local_var_req_builder.query(&[(
10370                "description__ic",
10371                &local_var_str
10372                    .into_iter()
10373                    .map(|p| p.to_string())
10374                    .collect::<Vec<String>>()
10375                    .join(",")
10376                    .to_string(),
10377            )]),
10378        };
10379    }
10380    if let Some(ref local_var_str) = description__ie {
10381        local_var_req_builder = match "multi" {
10382            "multi" => local_var_req_builder.query(
10383                &local_var_str
10384                    .into_iter()
10385                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10387            ),
10388            _ => local_var_req_builder.query(&[(
10389                "description__ie",
10390                &local_var_str
10391                    .into_iter()
10392                    .map(|p| p.to_string())
10393                    .collect::<Vec<String>>()
10394                    .join(",")
10395                    .to_string(),
10396            )]),
10397        };
10398    }
10399    if let Some(ref local_var_str) = description__iew {
10400        local_var_req_builder = match "multi" {
10401            "multi" => local_var_req_builder.query(
10402                &local_var_str
10403                    .into_iter()
10404                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10406            ),
10407            _ => local_var_req_builder.query(&[(
10408                "description__iew",
10409                &local_var_str
10410                    .into_iter()
10411                    .map(|p| p.to_string())
10412                    .collect::<Vec<String>>()
10413                    .join(",")
10414                    .to_string(),
10415            )]),
10416        };
10417    }
10418    if let Some(ref local_var_str) = description__iregex {
10419        local_var_req_builder = match "multi" {
10420            "multi" => local_var_req_builder.query(
10421                &local_var_str
10422                    .into_iter()
10423                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10425            ),
10426            _ => local_var_req_builder.query(&[(
10427                "description__iregex",
10428                &local_var_str
10429                    .into_iter()
10430                    .map(|p| p.to_string())
10431                    .collect::<Vec<String>>()
10432                    .join(",")
10433                    .to_string(),
10434            )]),
10435        };
10436    }
10437    if let Some(ref local_var_str) = description__isw {
10438        local_var_req_builder = match "multi" {
10439            "multi" => local_var_req_builder.query(
10440                &local_var_str
10441                    .into_iter()
10442                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10444            ),
10445            _ => local_var_req_builder.query(&[(
10446                "description__isw",
10447                &local_var_str
10448                    .into_iter()
10449                    .map(|p| p.to_string())
10450                    .collect::<Vec<String>>()
10451                    .join(",")
10452                    .to_string(),
10453            )]),
10454        };
10455    }
10456    if let Some(ref local_var_str) = description__n {
10457        local_var_req_builder = match "multi" {
10458            "multi" => local_var_req_builder.query(
10459                &local_var_str
10460                    .into_iter()
10461                    .map(|p| ("description__n".to_owned(), p.to_string()))
10462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10463            ),
10464            _ => local_var_req_builder.query(&[(
10465                "description__n",
10466                &local_var_str
10467                    .into_iter()
10468                    .map(|p| p.to_string())
10469                    .collect::<Vec<String>>()
10470                    .join(",")
10471                    .to_string(),
10472            )]),
10473        };
10474    }
10475    if let Some(ref local_var_str) = description__nic {
10476        local_var_req_builder = match "multi" {
10477            "multi" => local_var_req_builder.query(
10478                &local_var_str
10479                    .into_iter()
10480                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10482            ),
10483            _ => local_var_req_builder.query(&[(
10484                "description__nic",
10485                &local_var_str
10486                    .into_iter()
10487                    .map(|p| p.to_string())
10488                    .collect::<Vec<String>>()
10489                    .join(",")
10490                    .to_string(),
10491            )]),
10492        };
10493    }
10494    if let Some(ref local_var_str) = description__nie {
10495        local_var_req_builder = match "multi" {
10496            "multi" => local_var_req_builder.query(
10497                &local_var_str
10498                    .into_iter()
10499                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10501            ),
10502            _ => local_var_req_builder.query(&[(
10503                "description__nie",
10504                &local_var_str
10505                    .into_iter()
10506                    .map(|p| p.to_string())
10507                    .collect::<Vec<String>>()
10508                    .join(",")
10509                    .to_string(),
10510            )]),
10511        };
10512    }
10513    if let Some(ref local_var_str) = description__niew {
10514        local_var_req_builder = match "multi" {
10515            "multi" => local_var_req_builder.query(
10516                &local_var_str
10517                    .into_iter()
10518                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10520            ),
10521            _ => local_var_req_builder.query(&[(
10522                "description__niew",
10523                &local_var_str
10524                    .into_iter()
10525                    .map(|p| p.to_string())
10526                    .collect::<Vec<String>>()
10527                    .join(",")
10528                    .to_string(),
10529            )]),
10530        };
10531    }
10532    if let Some(ref local_var_str) = description__nisw {
10533        local_var_req_builder = match "multi" {
10534            "multi" => local_var_req_builder.query(
10535                &local_var_str
10536                    .into_iter()
10537                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10539            ),
10540            _ => local_var_req_builder.query(&[(
10541                "description__nisw",
10542                &local_var_str
10543                    .into_iter()
10544                    .map(|p| p.to_string())
10545                    .collect::<Vec<String>>()
10546                    .join(",")
10547                    .to_string(),
10548            )]),
10549        };
10550    }
10551    if let Some(ref local_var_str) = description__regex {
10552        local_var_req_builder = match "multi" {
10553            "multi" => local_var_req_builder.query(
10554                &local_var_str
10555                    .into_iter()
10556                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10558            ),
10559            _ => local_var_req_builder.query(&[(
10560                "description__regex",
10561                &local_var_str
10562                    .into_iter()
10563                    .map(|p| p.to_string())
10564                    .collect::<Vec<String>>()
10565                    .join(",")
10566                    .to_string(),
10567            )]),
10568        };
10569    }
10570    if let Some(ref local_var_str) = id {
10571        local_var_req_builder = match "multi" {
10572            "multi" => local_var_req_builder.query(
10573                &local_var_str
10574                    .into_iter()
10575                    .map(|p| ("id".to_owned(), p.to_string()))
10576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10577            ),
10578            _ => local_var_req_builder.query(&[(
10579                "id",
10580                &local_var_str
10581                    .into_iter()
10582                    .map(|p| p.to_string())
10583                    .collect::<Vec<String>>()
10584                    .join(",")
10585                    .to_string(),
10586            )]),
10587        };
10588    }
10589    if let Some(ref local_var_str) = id__empty {
10590        local_var_req_builder =
10591            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10592    }
10593    if let Some(ref local_var_str) = id__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| ("id__gt".to_owned(), p.to_string()))
10599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10600            ),
10601            _ => local_var_req_builder.query(&[(
10602                "id__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) = id__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| ("id__gte".to_owned(), p.to_string()))
10618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10619            ),
10620            _ => local_var_req_builder.query(&[(
10621                "id__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) = id__lt {
10632        local_var_req_builder = match "multi" {
10633            "multi" => local_var_req_builder.query(
10634                &local_var_str
10635                    .into_iter()
10636                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10638            ),
10639            _ => local_var_req_builder.query(&[(
10640                "id__lt",
10641                &local_var_str
10642                    .into_iter()
10643                    .map(|p| p.to_string())
10644                    .collect::<Vec<String>>()
10645                    .join(",")
10646                    .to_string(),
10647            )]),
10648        };
10649    }
10650    if let Some(ref local_var_str) = id__lte {
10651        local_var_req_builder = match "multi" {
10652            "multi" => local_var_req_builder.query(
10653                &local_var_str
10654                    .into_iter()
10655                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10657            ),
10658            _ => local_var_req_builder.query(&[(
10659                "id__lte",
10660                &local_var_str
10661                    .into_iter()
10662                    .map(|p| p.to_string())
10663                    .collect::<Vec<String>>()
10664                    .join(",")
10665                    .to_string(),
10666            )]),
10667        };
10668    }
10669    if let Some(ref local_var_str) = id__n {
10670        local_var_req_builder = match "multi" {
10671            "multi" => local_var_req_builder.query(
10672                &local_var_str
10673                    .into_iter()
10674                    .map(|p| ("id__n".to_owned(), p.to_string()))
10675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10676            ),
10677            _ => local_var_req_builder.query(&[(
10678                "id__n",
10679                &local_var_str
10680                    .into_iter()
10681                    .map(|p| p.to_string())
10682                    .collect::<Vec<String>>()
10683                    .join(",")
10684                    .to_string(),
10685            )]),
10686        };
10687    }
10688    if let Some(ref local_var_str) = last_updated {
10689        local_var_req_builder = match "multi" {
10690            "multi" => local_var_req_builder.query(
10691                &local_var_str
10692                    .into_iter()
10693                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10695            ),
10696            _ => local_var_req_builder.query(&[(
10697                "last_updated",
10698                &local_var_str
10699                    .into_iter()
10700                    .map(|p| p.to_string())
10701                    .collect::<Vec<String>>()
10702                    .join(",")
10703                    .to_string(),
10704            )]),
10705        };
10706    }
10707    if let Some(ref local_var_str) = last_updated__empty {
10708        local_var_req_builder = match "multi" {
10709            "multi" => local_var_req_builder.query(
10710                &local_var_str
10711                    .into_iter()
10712                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
10713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10714            ),
10715            _ => local_var_req_builder.query(&[(
10716                "last_updated__empty",
10717                &local_var_str
10718                    .into_iter()
10719                    .map(|p| p.to_string())
10720                    .collect::<Vec<String>>()
10721                    .join(",")
10722                    .to_string(),
10723            )]),
10724        };
10725    }
10726    if let Some(ref local_var_str) = last_updated__gt {
10727        local_var_req_builder = match "multi" {
10728            "multi" => local_var_req_builder.query(
10729                &local_var_str
10730                    .into_iter()
10731                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10733            ),
10734            _ => local_var_req_builder.query(&[(
10735                "last_updated__gt",
10736                &local_var_str
10737                    .into_iter()
10738                    .map(|p| p.to_string())
10739                    .collect::<Vec<String>>()
10740                    .join(",")
10741                    .to_string(),
10742            )]),
10743        };
10744    }
10745    if let Some(ref local_var_str) = last_updated__gte {
10746        local_var_req_builder = match "multi" {
10747            "multi" => local_var_req_builder.query(
10748                &local_var_str
10749                    .into_iter()
10750                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10752            ),
10753            _ => local_var_req_builder.query(&[(
10754                "last_updated__gte",
10755                &local_var_str
10756                    .into_iter()
10757                    .map(|p| p.to_string())
10758                    .collect::<Vec<String>>()
10759                    .join(",")
10760                    .to_string(),
10761            )]),
10762        };
10763    }
10764    if let Some(ref local_var_str) = last_updated__lt {
10765        local_var_req_builder = match "multi" {
10766            "multi" => local_var_req_builder.query(
10767                &local_var_str
10768                    .into_iter()
10769                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10771            ),
10772            _ => local_var_req_builder.query(&[(
10773                "last_updated__lt",
10774                &local_var_str
10775                    .into_iter()
10776                    .map(|p| p.to_string())
10777                    .collect::<Vec<String>>()
10778                    .join(",")
10779                    .to_string(),
10780            )]),
10781        };
10782    }
10783    if let Some(ref local_var_str) = last_updated__lte {
10784        local_var_req_builder = match "multi" {
10785            "multi" => local_var_req_builder.query(
10786                &local_var_str
10787                    .into_iter()
10788                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10790            ),
10791            _ => local_var_req_builder.query(&[(
10792                "last_updated__lte",
10793                &local_var_str
10794                    .into_iter()
10795                    .map(|p| p.to_string())
10796                    .collect::<Vec<String>>()
10797                    .join(",")
10798                    .to_string(),
10799            )]),
10800        };
10801    }
10802    if let Some(ref local_var_str) = last_updated__n {
10803        local_var_req_builder = match "multi" {
10804            "multi" => local_var_req_builder.query(
10805                &local_var_str
10806                    .into_iter()
10807                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10809            ),
10810            _ => local_var_req_builder.query(&[(
10811                "last_updated__n",
10812                &local_var_str
10813                    .into_iter()
10814                    .map(|p| p.to_string())
10815                    .collect::<Vec<String>>()
10816                    .join(",")
10817                    .to_string(),
10818            )]),
10819        };
10820    }
10821    if let Some(ref local_var_str) = limit {
10822        local_var_req_builder =
10823            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10824    }
10825    if let Some(ref local_var_str) = modified_by_request {
10826        local_var_req_builder =
10827            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
10828    }
10829    if let Some(ref local_var_str) = name {
10830        local_var_req_builder = match "multi" {
10831            "multi" => local_var_req_builder.query(
10832                &local_var_str
10833                    .into_iter()
10834                    .map(|p| ("name".to_owned(), p.to_string()))
10835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10836            ),
10837            _ => local_var_req_builder.query(&[(
10838                "name",
10839                &local_var_str
10840                    .into_iter()
10841                    .map(|p| p.to_string())
10842                    .collect::<Vec<String>>()
10843                    .join(",")
10844                    .to_string(),
10845            )]),
10846        };
10847    }
10848    if let Some(ref local_var_str) = name__empty {
10849        local_var_req_builder =
10850            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
10851    }
10852    if let Some(ref local_var_str) = name__ic {
10853        local_var_req_builder = match "multi" {
10854            "multi" => local_var_req_builder.query(
10855                &local_var_str
10856                    .into_iter()
10857                    .map(|p| ("name__ic".to_owned(), p.to_string()))
10858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10859            ),
10860            _ => local_var_req_builder.query(&[(
10861                "name__ic",
10862                &local_var_str
10863                    .into_iter()
10864                    .map(|p| p.to_string())
10865                    .collect::<Vec<String>>()
10866                    .join(",")
10867                    .to_string(),
10868            )]),
10869        };
10870    }
10871    if let Some(ref local_var_str) = name__ie {
10872        local_var_req_builder = match "multi" {
10873            "multi" => local_var_req_builder.query(
10874                &local_var_str
10875                    .into_iter()
10876                    .map(|p| ("name__ie".to_owned(), p.to_string()))
10877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10878            ),
10879            _ => local_var_req_builder.query(&[(
10880                "name__ie",
10881                &local_var_str
10882                    .into_iter()
10883                    .map(|p| p.to_string())
10884                    .collect::<Vec<String>>()
10885                    .join(",")
10886                    .to_string(),
10887            )]),
10888        };
10889    }
10890    if let Some(ref local_var_str) = name__iew {
10891        local_var_req_builder = match "multi" {
10892            "multi" => local_var_req_builder.query(
10893                &local_var_str
10894                    .into_iter()
10895                    .map(|p| ("name__iew".to_owned(), p.to_string()))
10896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10897            ),
10898            _ => local_var_req_builder.query(&[(
10899                "name__iew",
10900                &local_var_str
10901                    .into_iter()
10902                    .map(|p| p.to_string())
10903                    .collect::<Vec<String>>()
10904                    .join(",")
10905                    .to_string(),
10906            )]),
10907        };
10908    }
10909    if let Some(ref local_var_str) = name__iregex {
10910        local_var_req_builder = match "multi" {
10911            "multi" => local_var_req_builder.query(
10912                &local_var_str
10913                    .into_iter()
10914                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
10915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10916            ),
10917            _ => local_var_req_builder.query(&[(
10918                "name__iregex",
10919                &local_var_str
10920                    .into_iter()
10921                    .map(|p| p.to_string())
10922                    .collect::<Vec<String>>()
10923                    .join(",")
10924                    .to_string(),
10925            )]),
10926        };
10927    }
10928    if let Some(ref local_var_str) = name__isw {
10929        local_var_req_builder = match "multi" {
10930            "multi" => local_var_req_builder.query(
10931                &local_var_str
10932                    .into_iter()
10933                    .map(|p| ("name__isw".to_owned(), p.to_string()))
10934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10935            ),
10936            _ => local_var_req_builder.query(&[(
10937                "name__isw",
10938                &local_var_str
10939                    .into_iter()
10940                    .map(|p| p.to_string())
10941                    .collect::<Vec<String>>()
10942                    .join(",")
10943                    .to_string(),
10944            )]),
10945        };
10946    }
10947    if let Some(ref local_var_str) = name__n {
10948        local_var_req_builder = match "multi" {
10949            "multi" => local_var_req_builder.query(
10950                &local_var_str
10951                    .into_iter()
10952                    .map(|p| ("name__n".to_owned(), p.to_string()))
10953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10954            ),
10955            _ => local_var_req_builder.query(&[(
10956                "name__n",
10957                &local_var_str
10958                    .into_iter()
10959                    .map(|p| p.to_string())
10960                    .collect::<Vec<String>>()
10961                    .join(",")
10962                    .to_string(),
10963            )]),
10964        };
10965    }
10966    if let Some(ref local_var_str) = name__nic {
10967        local_var_req_builder = match "multi" {
10968            "multi" => local_var_req_builder.query(
10969                &local_var_str
10970                    .into_iter()
10971                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10973            ),
10974            _ => local_var_req_builder.query(&[(
10975                "name__nic",
10976                &local_var_str
10977                    .into_iter()
10978                    .map(|p| p.to_string())
10979                    .collect::<Vec<String>>()
10980                    .join(",")
10981                    .to_string(),
10982            )]),
10983        };
10984    }
10985    if let Some(ref local_var_str) = name__nie {
10986        local_var_req_builder = match "multi" {
10987            "multi" => local_var_req_builder.query(
10988                &local_var_str
10989                    .into_iter()
10990                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10992            ),
10993            _ => local_var_req_builder.query(&[(
10994                "name__nie",
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) = name__niew {
11005        local_var_req_builder = match "multi" {
11006            "multi" => local_var_req_builder.query(
11007                &local_var_str
11008                    .into_iter()
11009                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11011            ),
11012            _ => local_var_req_builder.query(&[(
11013                "name__niew",
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) = name__nisw {
11024        local_var_req_builder = match "multi" {
11025            "multi" => local_var_req_builder.query(
11026                &local_var_str
11027                    .into_iter()
11028                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11030            ),
11031            _ => local_var_req_builder.query(&[(
11032                "name__nisw",
11033                &local_var_str
11034                    .into_iter()
11035                    .map(|p| p.to_string())
11036                    .collect::<Vec<String>>()
11037                    .join(",")
11038                    .to_string(),
11039            )]),
11040        };
11041    }
11042    if let Some(ref local_var_str) = name__regex {
11043        local_var_req_builder = match "multi" {
11044            "multi" => local_var_req_builder.query(
11045                &local_var_str
11046                    .into_iter()
11047                    .map(|p| ("name__regex".to_owned(), p.to_string()))
11048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11049            ),
11050            _ => local_var_req_builder.query(&[(
11051                "name__regex",
11052                &local_var_str
11053                    .into_iter()
11054                    .map(|p| p.to_string())
11055                    .collect::<Vec<String>>()
11056                    .join(",")
11057                    .to_string(),
11058            )]),
11059        };
11060    }
11061    if let Some(ref local_var_str) = offset {
11062        local_var_req_builder =
11063            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11064    }
11065    if let Some(ref local_var_str) = ordering {
11066        local_var_req_builder =
11067            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11068    }
11069    if let Some(ref local_var_str) = owner {
11070        local_var_req_builder = match "multi" {
11071            "multi" => local_var_req_builder.query(
11072                &local_var_str
11073                    .into_iter()
11074                    .map(|p| ("owner".to_owned(), p.to_string()))
11075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11076            ),
11077            _ => local_var_req_builder.query(&[(
11078                "owner",
11079                &local_var_str
11080                    .into_iter()
11081                    .map(|p| p.to_string())
11082                    .collect::<Vec<String>>()
11083                    .join(",")
11084                    .to_string(),
11085            )]),
11086        };
11087    }
11088    if let Some(ref local_var_str) = owner__n {
11089        local_var_req_builder = match "multi" {
11090            "multi" => local_var_req_builder.query(
11091                &local_var_str
11092                    .into_iter()
11093                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11095            ),
11096            _ => local_var_req_builder.query(&[(
11097                "owner__n",
11098                &local_var_str
11099                    .into_iter()
11100                    .map(|p| p.to_string())
11101                    .collect::<Vec<String>>()
11102                    .join(",")
11103                    .to_string(),
11104            )]),
11105        };
11106    }
11107    if let Some(ref local_var_str) = owner_group {
11108        local_var_req_builder = match "multi" {
11109            "multi" => local_var_req_builder.query(
11110                &local_var_str
11111                    .into_iter()
11112                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11114            ),
11115            _ => local_var_req_builder.query(&[(
11116                "owner_group",
11117                &local_var_str
11118                    .into_iter()
11119                    .map(|p| p.to_string())
11120                    .collect::<Vec<String>>()
11121                    .join(",")
11122                    .to_string(),
11123            )]),
11124        };
11125    }
11126    if let Some(ref local_var_str) = owner_group__n {
11127        local_var_req_builder = match "multi" {
11128            "multi" => local_var_req_builder.query(
11129                &local_var_str
11130                    .into_iter()
11131                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11133            ),
11134            _ => local_var_req_builder.query(&[(
11135                "owner_group__n",
11136                &local_var_str
11137                    .into_iter()
11138                    .map(|p| p.to_string())
11139                    .collect::<Vec<String>>()
11140                    .join(",")
11141                    .to_string(),
11142            )]),
11143        };
11144    }
11145    if let Some(ref local_var_str) = owner_group_id {
11146        local_var_req_builder = match "multi" {
11147            "multi" => local_var_req_builder.query(
11148                &local_var_str
11149                    .into_iter()
11150                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11152            ),
11153            _ => local_var_req_builder.query(&[(
11154                "owner_group_id",
11155                &local_var_str
11156                    .into_iter()
11157                    .map(|p| p.to_string())
11158                    .collect::<Vec<String>>()
11159                    .join(",")
11160                    .to_string(),
11161            )]),
11162        };
11163    }
11164    if let Some(ref local_var_str) = owner_group_id__n {
11165        local_var_req_builder = match "multi" {
11166            "multi" => local_var_req_builder.query(
11167                &local_var_str
11168                    .into_iter()
11169                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11171            ),
11172            _ => local_var_req_builder.query(&[(
11173                "owner_group_id__n",
11174                &local_var_str
11175                    .into_iter()
11176                    .map(|p| p.to_string())
11177                    .collect::<Vec<String>>()
11178                    .join(",")
11179                    .to_string(),
11180            )]),
11181        };
11182    }
11183    if let Some(ref local_var_str) = owner_id {
11184        local_var_req_builder = match "multi" {
11185            "multi" => local_var_req_builder.query(
11186                &local_var_str
11187                    .into_iter()
11188                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11190            ),
11191            _ => local_var_req_builder.query(&[(
11192                "owner_id",
11193                &local_var_str
11194                    .into_iter()
11195                    .map(|p| p.to_string())
11196                    .collect::<Vec<String>>()
11197                    .join(",")
11198                    .to_string(),
11199            )]),
11200        };
11201    }
11202    if let Some(ref local_var_str) = owner_id__n {
11203        local_var_req_builder = match "multi" {
11204            "multi" => local_var_req_builder.query(
11205                &local_var_str
11206                    .into_iter()
11207                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11209            ),
11210            _ => local_var_req_builder.query(&[(
11211                "owner_id__n",
11212                &local_var_str
11213                    .into_iter()
11214                    .map(|p| p.to_string())
11215                    .collect::<Vec<String>>()
11216                    .join(",")
11217                    .to_string(),
11218            )]),
11219        };
11220    }
11221    if let Some(ref local_var_str) = q {
11222        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11223    }
11224    if let Some(ref local_var_str) = size {
11225        local_var_req_builder = match "multi" {
11226            "multi" => local_var_req_builder.query(
11227                &local_var_str
11228                    .into_iter()
11229                    .map(|p| ("size".to_owned(), p.to_string()))
11230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11231            ),
11232            _ => local_var_req_builder.query(&[(
11233                "size",
11234                &local_var_str
11235                    .into_iter()
11236                    .map(|p| p.to_string())
11237                    .collect::<Vec<String>>()
11238                    .join(",")
11239                    .to_string(),
11240            )]),
11241        };
11242    }
11243    if let Some(ref local_var_str) = size__empty {
11244        local_var_req_builder =
11245            local_var_req_builder.query(&[("size__empty", &local_var_str.to_string())]);
11246    }
11247    if let Some(ref local_var_str) = size__gt {
11248        local_var_req_builder = match "multi" {
11249            "multi" => local_var_req_builder.query(
11250                &local_var_str
11251                    .into_iter()
11252                    .map(|p| ("size__gt".to_owned(), p.to_string()))
11253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11254            ),
11255            _ => local_var_req_builder.query(&[(
11256                "size__gt",
11257                &local_var_str
11258                    .into_iter()
11259                    .map(|p| p.to_string())
11260                    .collect::<Vec<String>>()
11261                    .join(",")
11262                    .to_string(),
11263            )]),
11264        };
11265    }
11266    if let Some(ref local_var_str) = size__gte {
11267        local_var_req_builder = match "multi" {
11268            "multi" => local_var_req_builder.query(
11269                &local_var_str
11270                    .into_iter()
11271                    .map(|p| ("size__gte".to_owned(), p.to_string()))
11272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11273            ),
11274            _ => local_var_req_builder.query(&[(
11275                "size__gte",
11276                &local_var_str
11277                    .into_iter()
11278                    .map(|p| p.to_string())
11279                    .collect::<Vec<String>>()
11280                    .join(",")
11281                    .to_string(),
11282            )]),
11283        };
11284    }
11285    if let Some(ref local_var_str) = size__lt {
11286        local_var_req_builder = match "multi" {
11287            "multi" => local_var_req_builder.query(
11288                &local_var_str
11289                    .into_iter()
11290                    .map(|p| ("size__lt".to_owned(), p.to_string()))
11291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11292            ),
11293            _ => local_var_req_builder.query(&[(
11294                "size__lt",
11295                &local_var_str
11296                    .into_iter()
11297                    .map(|p| p.to_string())
11298                    .collect::<Vec<String>>()
11299                    .join(",")
11300                    .to_string(),
11301            )]),
11302        };
11303    }
11304    if let Some(ref local_var_str) = size__lte {
11305        local_var_req_builder = match "multi" {
11306            "multi" => local_var_req_builder.query(
11307                &local_var_str
11308                    .into_iter()
11309                    .map(|p| ("size__lte".to_owned(), p.to_string()))
11310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11311            ),
11312            _ => local_var_req_builder.query(&[(
11313                "size__lte",
11314                &local_var_str
11315                    .into_iter()
11316                    .map(|p| p.to_string())
11317                    .collect::<Vec<String>>()
11318                    .join(",")
11319                    .to_string(),
11320            )]),
11321        };
11322    }
11323    if let Some(ref local_var_str) = size__n {
11324        local_var_req_builder = match "multi" {
11325            "multi" => local_var_req_builder.query(
11326                &local_var_str
11327                    .into_iter()
11328                    .map(|p| ("size__n".to_owned(), p.to_string()))
11329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11330            ),
11331            _ => local_var_req_builder.query(&[(
11332                "size__n",
11333                &local_var_str
11334                    .into_iter()
11335                    .map(|p| p.to_string())
11336                    .collect::<Vec<String>>()
11337                    .join(",")
11338                    .to_string(),
11339            )]),
11340        };
11341    }
11342    if let Some(ref local_var_str) = tag {
11343        local_var_req_builder = match "multi" {
11344            "multi" => local_var_req_builder.query(
11345                &local_var_str
11346                    .into_iter()
11347                    .map(|p| ("tag".to_owned(), p.to_string()))
11348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11349            ),
11350            _ => local_var_req_builder.query(&[(
11351                "tag",
11352                &local_var_str
11353                    .into_iter()
11354                    .map(|p| p.to_string())
11355                    .collect::<Vec<String>>()
11356                    .join(",")
11357                    .to_string(),
11358            )]),
11359        };
11360    }
11361    if let Some(ref local_var_str) = tag__n {
11362        local_var_req_builder = match "multi" {
11363            "multi" => local_var_req_builder.query(
11364                &local_var_str
11365                    .into_iter()
11366                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11368            ),
11369            _ => local_var_req_builder.query(&[(
11370                "tag__n",
11371                &local_var_str
11372                    .into_iter()
11373                    .map(|p| p.to_string())
11374                    .collect::<Vec<String>>()
11375                    .join(",")
11376                    .to_string(),
11377            )]),
11378        };
11379    }
11380    if let Some(ref local_var_str) = tag_id {
11381        local_var_req_builder = match "multi" {
11382            "multi" => local_var_req_builder.query(
11383                &local_var_str
11384                    .into_iter()
11385                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11387            ),
11388            _ => local_var_req_builder.query(&[(
11389                "tag_id",
11390                &local_var_str
11391                    .into_iter()
11392                    .map(|p| p.to_string())
11393                    .collect::<Vec<String>>()
11394                    .join(",")
11395                    .to_string(),
11396            )]),
11397        };
11398    }
11399    if let Some(ref local_var_str) = tag_id__n {
11400        local_var_req_builder = match "multi" {
11401            "multi" => local_var_req_builder.query(
11402                &local_var_str
11403                    .into_iter()
11404                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11406            ),
11407            _ => local_var_req_builder.query(&[(
11408                "tag_id__n",
11409                &local_var_str
11410                    .into_iter()
11411                    .map(|p| p.to_string())
11412                    .collect::<Vec<String>>()
11413                    .join(",")
11414                    .to_string(),
11415            )]),
11416        };
11417    }
11418    if let Some(ref local_var_str) = updated_by_request {
11419        local_var_req_builder =
11420            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11421    }
11422    if let Some(ref local_var_str) = virtual_machine {
11423        local_var_req_builder = match "multi" {
11424            "multi" => local_var_req_builder.query(
11425                &local_var_str
11426                    .into_iter()
11427                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
11428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11429            ),
11430            _ => local_var_req_builder.query(&[(
11431                "virtual_machine",
11432                &local_var_str
11433                    .into_iter()
11434                    .map(|p| p.to_string())
11435                    .collect::<Vec<String>>()
11436                    .join(",")
11437                    .to_string(),
11438            )]),
11439        };
11440    }
11441    if let Some(ref local_var_str) = virtual_machine__n {
11442        local_var_req_builder = match "multi" {
11443            "multi" => local_var_req_builder.query(
11444                &local_var_str
11445                    .into_iter()
11446                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
11447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11448            ),
11449            _ => local_var_req_builder.query(&[(
11450                "virtual_machine__n",
11451                &local_var_str
11452                    .into_iter()
11453                    .map(|p| p.to_string())
11454                    .collect::<Vec<String>>()
11455                    .join(",")
11456                    .to_string(),
11457            )]),
11458        };
11459    }
11460    if let Some(ref local_var_str) = virtual_machine_id {
11461        local_var_req_builder = match "multi" {
11462            "multi" => local_var_req_builder.query(
11463                &local_var_str
11464                    .into_iter()
11465                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
11466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11467            ),
11468            _ => local_var_req_builder.query(&[(
11469                "virtual_machine_id",
11470                &local_var_str
11471                    .into_iter()
11472                    .map(|p| p.to_string())
11473                    .collect::<Vec<String>>()
11474                    .join(",")
11475                    .to_string(),
11476            )]),
11477        };
11478    }
11479    if let Some(ref local_var_str) = virtual_machine_id__n {
11480        local_var_req_builder = match "multi" {
11481            "multi" => local_var_req_builder.query(
11482                &local_var_str
11483                    .into_iter()
11484                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
11485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11486            ),
11487            _ => local_var_req_builder.query(&[(
11488                "virtual_machine_id__n",
11489                &local_var_str
11490                    .into_iter()
11491                    .map(|p| p.to_string())
11492                    .collect::<Vec<String>>()
11493                    .join(",")
11494                    .to_string(),
11495            )]),
11496        };
11497    }
11498    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11499        local_var_req_builder =
11500            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11501    }
11502    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11503        let local_var_key = local_var_apikey.key.clone();
11504        let local_var_value = match local_var_apikey.prefix {
11505            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11506            None => local_var_key,
11507        };
11508        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11509    };
11510
11511    let local_var_req = local_var_req_builder.build()?;
11512    let local_var_resp = local_var_client.execute(local_var_req).await?;
11513
11514    let local_var_status = local_var_resp.status();
11515    let local_var_content = local_var_resp.text().await?;
11516
11517    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11518        serde_json::from_str(&local_var_content).map_err(Error::from)
11519    } else {
11520        let local_var_entity: Option<VirtualizationVirtualDisksListError> =
11521            serde_json::from_str(&local_var_content).ok();
11522        let local_var_error = ResponseContent {
11523            status: local_var_status,
11524            content: local_var_content,
11525            entity: local_var_entity,
11526        };
11527        Err(Error::ResponseError(local_var_error))
11528    }
11529}
11530
11531/// Patch a virtual disk object.
11532pub async fn virtualization_virtual_disks_partial_update(
11533    configuration: &configuration::Configuration,
11534    id: i32,
11535    patched_virtual_disk_request: Option<crate::models::PatchedVirtualDiskRequest>,
11536) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksPartialUpdateError>> {
11537    let local_var_configuration = configuration;
11538
11539    let local_var_client = &local_var_configuration.client;
11540
11541    let local_var_uri_str = format!(
11542        "{}/api/virtualization/virtual-disks/{id}/",
11543        local_var_configuration.base_path,
11544        id = id
11545    );
11546    let mut local_var_req_builder =
11547        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11548
11549    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11550        local_var_req_builder =
11551            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11552    }
11553    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11554        let local_var_key = local_var_apikey.key.clone();
11555        let local_var_value = match local_var_apikey.prefix {
11556            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11557            None => local_var_key,
11558        };
11559        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11560    };
11561    local_var_req_builder = local_var_req_builder.json(&patched_virtual_disk_request);
11562
11563    let local_var_req = local_var_req_builder.build()?;
11564    let local_var_resp = local_var_client.execute(local_var_req).await?;
11565
11566    let local_var_status = local_var_resp.status();
11567    let local_var_content = local_var_resp.text().await?;
11568
11569    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11570        serde_json::from_str(&local_var_content).map_err(Error::from)
11571    } else {
11572        let local_var_entity: Option<VirtualizationVirtualDisksPartialUpdateError> =
11573            serde_json::from_str(&local_var_content).ok();
11574        let local_var_error = ResponseContent {
11575            status: local_var_status,
11576            content: local_var_content,
11577            entity: local_var_entity,
11578        };
11579        Err(Error::ResponseError(local_var_error))
11580    }
11581}
11582
11583/// Get a virtual disk object.
11584pub async fn virtualization_virtual_disks_retrieve(
11585    configuration: &configuration::Configuration,
11586    id: i32,
11587) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksRetrieveError>> {
11588    let local_var_configuration = configuration;
11589
11590    let local_var_client = &local_var_configuration.client;
11591
11592    let local_var_uri_str = format!(
11593        "{}/api/virtualization/virtual-disks/{id}/",
11594        local_var_configuration.base_path,
11595        id = id
11596    );
11597    let mut local_var_req_builder =
11598        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11599
11600    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11601        local_var_req_builder =
11602            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11603    }
11604    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11605        let local_var_key = local_var_apikey.key.clone();
11606        let local_var_value = match local_var_apikey.prefix {
11607            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11608            None => local_var_key,
11609        };
11610        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11611    };
11612
11613    let local_var_req = local_var_req_builder.build()?;
11614    let local_var_resp = local_var_client.execute(local_var_req).await?;
11615
11616    let local_var_status = local_var_resp.status();
11617    let local_var_content = local_var_resp.text().await?;
11618
11619    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11620        serde_json::from_str(&local_var_content).map_err(Error::from)
11621    } else {
11622        let local_var_entity: Option<VirtualizationVirtualDisksRetrieveError> =
11623            serde_json::from_str(&local_var_content).ok();
11624        let local_var_error = ResponseContent {
11625            status: local_var_status,
11626            content: local_var_content,
11627            entity: local_var_entity,
11628        };
11629        Err(Error::ResponseError(local_var_error))
11630    }
11631}
11632
11633/// Put a virtual disk object.
11634pub async fn virtualization_virtual_disks_update(
11635    configuration: &configuration::Configuration,
11636    id: i32,
11637    virtual_disk_request: crate::models::VirtualDiskRequest,
11638) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksUpdateError>> {
11639    let local_var_configuration = configuration;
11640
11641    let local_var_client = &local_var_configuration.client;
11642
11643    let local_var_uri_str = format!(
11644        "{}/api/virtualization/virtual-disks/{id}/",
11645        local_var_configuration.base_path,
11646        id = id
11647    );
11648    let mut local_var_req_builder =
11649        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11650
11651    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11652        local_var_req_builder =
11653            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11654    }
11655    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11656        let local_var_key = local_var_apikey.key.clone();
11657        let local_var_value = match local_var_apikey.prefix {
11658            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11659            None => local_var_key,
11660        };
11661        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11662    };
11663    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
11664
11665    let local_var_req = local_var_req_builder.build()?;
11666    let local_var_resp = local_var_client.execute(local_var_req).await?;
11667
11668    let local_var_status = local_var_resp.status();
11669    let local_var_content = local_var_resp.text().await?;
11670
11671    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11672        serde_json::from_str(&local_var_content).map_err(Error::from)
11673    } else {
11674        let local_var_entity: Option<VirtualizationVirtualDisksUpdateError> =
11675            serde_json::from_str(&local_var_content).ok();
11676        let local_var_error = ResponseContent {
11677            status: local_var_status,
11678            content: local_var_content,
11679            entity: local_var_entity,
11680        };
11681        Err(Error::ResponseError(local_var_error))
11682    }
11683}
11684
11685/// Delete a list of virtual machine objects.
11686pub async fn virtualization_virtual_machines_bulk_destroy(
11687    configuration: &configuration::Configuration,
11688    virtual_machine_with_config_context_request: Vec<
11689        crate::models::VirtualMachineWithConfigContextRequest,
11690    >,
11691) -> Result<(), Error<VirtualizationVirtualMachinesBulkDestroyError>> {
11692    let local_var_configuration = configuration;
11693
11694    let local_var_client = &local_var_configuration.client;
11695
11696    let local_var_uri_str = format!(
11697        "{}/api/virtualization/virtual-machines/",
11698        local_var_configuration.base_path
11699    );
11700    let mut local_var_req_builder =
11701        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11702
11703    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11704        local_var_req_builder =
11705            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11706    }
11707    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11708        let local_var_key = local_var_apikey.key.clone();
11709        let local_var_value = match local_var_apikey.prefix {
11710            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11711            None => local_var_key,
11712        };
11713        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11714    };
11715    local_var_req_builder =
11716        local_var_req_builder.json(&virtual_machine_with_config_context_request);
11717
11718    let local_var_req = local_var_req_builder.build()?;
11719    let local_var_resp = local_var_client.execute(local_var_req).await?;
11720
11721    let local_var_status = local_var_resp.status();
11722    let local_var_content = local_var_resp.text().await?;
11723
11724    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11725        Ok(())
11726    } else {
11727        let local_var_entity: Option<VirtualizationVirtualMachinesBulkDestroyError> =
11728            serde_json::from_str(&local_var_content).ok();
11729        let local_var_error = ResponseContent {
11730            status: local_var_status,
11731            content: local_var_content,
11732            entity: local_var_entity,
11733        };
11734        Err(Error::ResponseError(local_var_error))
11735    }
11736}
11737
11738/// Patch a list of virtual machine objects.
11739pub async fn virtualization_virtual_machines_bulk_partial_update(
11740    configuration: &configuration::Configuration,
11741    virtual_machine_with_config_context_request: Vec<
11742        crate::models::VirtualMachineWithConfigContextRequest,
11743    >,
11744) -> Result<
11745    Vec<crate::models::VirtualMachineWithConfigContext>,
11746    Error<VirtualizationVirtualMachinesBulkPartialUpdateError>,
11747> {
11748    let local_var_configuration = configuration;
11749
11750    let local_var_client = &local_var_configuration.client;
11751
11752    let local_var_uri_str = format!(
11753        "{}/api/virtualization/virtual-machines/",
11754        local_var_configuration.base_path
11755    );
11756    let mut local_var_req_builder =
11757        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11758
11759    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11760        local_var_req_builder =
11761            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11762    }
11763    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11764        let local_var_key = local_var_apikey.key.clone();
11765        let local_var_value = match local_var_apikey.prefix {
11766            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11767            None => local_var_key,
11768        };
11769        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11770    };
11771    local_var_req_builder =
11772        local_var_req_builder.json(&virtual_machine_with_config_context_request);
11773
11774    let local_var_req = local_var_req_builder.build()?;
11775    let local_var_resp = local_var_client.execute(local_var_req).await?;
11776
11777    let local_var_status = local_var_resp.status();
11778    let local_var_content = local_var_resp.text().await?;
11779
11780    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11781        serde_json::from_str(&local_var_content).map_err(Error::from)
11782    } else {
11783        let local_var_entity: Option<VirtualizationVirtualMachinesBulkPartialUpdateError> =
11784            serde_json::from_str(&local_var_content).ok();
11785        let local_var_error = ResponseContent {
11786            status: local_var_status,
11787            content: local_var_content,
11788            entity: local_var_entity,
11789        };
11790        Err(Error::ResponseError(local_var_error))
11791    }
11792}
11793
11794/// Put a list of virtual machine objects.
11795pub async fn virtualization_virtual_machines_bulk_update(
11796    configuration: &configuration::Configuration,
11797    virtual_machine_with_config_context_request: Vec<
11798        crate::models::VirtualMachineWithConfigContextRequest,
11799    >,
11800) -> Result<
11801    Vec<crate::models::VirtualMachineWithConfigContext>,
11802    Error<VirtualizationVirtualMachinesBulkUpdateError>,
11803> {
11804    let local_var_configuration = configuration;
11805
11806    let local_var_client = &local_var_configuration.client;
11807
11808    let local_var_uri_str = format!(
11809        "{}/api/virtualization/virtual-machines/",
11810        local_var_configuration.base_path
11811    );
11812    let mut local_var_req_builder =
11813        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11814
11815    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11816        local_var_req_builder =
11817            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11818    }
11819    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11820        let local_var_key = local_var_apikey.key.clone();
11821        let local_var_value = match local_var_apikey.prefix {
11822            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11823            None => local_var_key,
11824        };
11825        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11826    };
11827    local_var_req_builder =
11828        local_var_req_builder.json(&virtual_machine_with_config_context_request);
11829
11830    let local_var_req = local_var_req_builder.build()?;
11831    let local_var_resp = local_var_client.execute(local_var_req).await?;
11832
11833    let local_var_status = local_var_resp.status();
11834    let local_var_content = local_var_resp.text().await?;
11835
11836    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11837        serde_json::from_str(&local_var_content).map_err(Error::from)
11838    } else {
11839        let local_var_entity: Option<VirtualizationVirtualMachinesBulkUpdateError> =
11840            serde_json::from_str(&local_var_content).ok();
11841        let local_var_error = ResponseContent {
11842            status: local_var_status,
11843            content: local_var_content,
11844            entity: local_var_entity,
11845        };
11846        Err(Error::ResponseError(local_var_error))
11847    }
11848}
11849
11850/// Post a list of virtual machine objects.
11851pub async fn virtualization_virtual_machines_create(
11852    configuration: &configuration::Configuration,
11853    virtualization_virtual_machines_create_request: crate::models::VirtualizationVirtualMachinesCreateRequest,
11854) -> Result<
11855    crate::models::VirtualMachineWithConfigContext,
11856    Error<VirtualizationVirtualMachinesCreateError>,
11857> {
11858    let local_var_configuration = configuration;
11859
11860    let local_var_client = &local_var_configuration.client;
11861
11862    let local_var_uri_str = format!(
11863        "{}/api/virtualization/virtual-machines/",
11864        local_var_configuration.base_path
11865    );
11866    let mut local_var_req_builder =
11867        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11868
11869    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11870        local_var_req_builder =
11871            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11872    }
11873    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11874        let local_var_key = local_var_apikey.key.clone();
11875        let local_var_value = match local_var_apikey.prefix {
11876            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11877            None => local_var_key,
11878        };
11879        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11880    };
11881    local_var_req_builder =
11882        local_var_req_builder.json(&virtualization_virtual_machines_create_request);
11883
11884    let local_var_req = local_var_req_builder.build()?;
11885    let local_var_resp = local_var_client.execute(local_var_req).await?;
11886
11887    let local_var_status = local_var_resp.status();
11888    let local_var_content = local_var_resp.text().await?;
11889
11890    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11891        serde_json::from_str(&local_var_content).map_err(Error::from)
11892    } else {
11893        let local_var_entity: Option<VirtualizationVirtualMachinesCreateError> =
11894            serde_json::from_str(&local_var_content).ok();
11895        let local_var_error = ResponseContent {
11896            status: local_var_status,
11897            content: local_var_content,
11898            entity: local_var_entity,
11899        };
11900        Err(Error::ResponseError(local_var_error))
11901    }
11902}
11903
11904/// Delete a virtual machine object.
11905pub async fn virtualization_virtual_machines_destroy(
11906    configuration: &configuration::Configuration,
11907    id: i32,
11908) -> Result<(), Error<VirtualizationVirtualMachinesDestroyError>> {
11909    let local_var_configuration = configuration;
11910
11911    let local_var_client = &local_var_configuration.client;
11912
11913    let local_var_uri_str = format!(
11914        "{}/api/virtualization/virtual-machines/{id}/",
11915        local_var_configuration.base_path,
11916        id = id
11917    );
11918    let mut local_var_req_builder =
11919        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11920
11921    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11922        local_var_req_builder =
11923            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11924    }
11925    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11926        let local_var_key = local_var_apikey.key.clone();
11927        let local_var_value = match local_var_apikey.prefix {
11928            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11929            None => local_var_key,
11930        };
11931        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11932    };
11933
11934    let local_var_req = local_var_req_builder.build()?;
11935    let local_var_resp = local_var_client.execute(local_var_req).await?;
11936
11937    let local_var_status = local_var_resp.status();
11938    let local_var_content = local_var_resp.text().await?;
11939
11940    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11941        Ok(())
11942    } else {
11943        let local_var_entity: Option<VirtualizationVirtualMachinesDestroyError> =
11944            serde_json::from_str(&local_var_content).ok();
11945        let local_var_error = ResponseContent {
11946            status: local_var_status,
11947            content: local_var_content,
11948            entity: local_var_entity,
11949        };
11950        Err(Error::ResponseError(local_var_error))
11951    }
11952}
11953
11954/// Get a list of virtual machine objects.
11955pub async fn virtualization_virtual_machines_list(
11956    configuration: &configuration::Configuration,
11957    cluster: Option<Vec<String>>,
11958    cluster__n: Option<Vec<String>>,
11959    cluster_group: Option<Vec<String>>,
11960    cluster_group__n: Option<Vec<String>>,
11961    cluster_group_id: Option<Vec<i32>>,
11962    cluster_group_id__n: Option<Vec<i32>>,
11963    cluster_id: Option<Vec<i32>>,
11964    cluster_id__n: Option<Vec<i32>>,
11965    cluster_type: Option<Vec<String>>,
11966    cluster_type__n: Option<Vec<String>>,
11967    cluster_type_id: Option<Vec<i32>>,
11968    cluster_type_id__n: Option<Vec<i32>>,
11969    config_template_id: Option<Vec<i32>>,
11970    config_template_id__n: Option<Vec<i32>>,
11971    contact: Option<Vec<i32>>,
11972    contact__n: Option<Vec<i32>>,
11973    contact_group: Option<Vec<String>>,
11974    contact_group__n: Option<Vec<String>>,
11975    contact_role: Option<Vec<i32>>,
11976    contact_role__n: Option<Vec<i32>>,
11977    created: Option<Vec<String>>,
11978    created__empty: Option<Vec<String>>,
11979    created__gt: Option<Vec<String>>,
11980    created__gte: Option<Vec<String>>,
11981    created__lt: Option<Vec<String>>,
11982    created__lte: Option<Vec<String>>,
11983    created__n: Option<Vec<String>>,
11984    created_by_request: Option<&str>,
11985    description: Option<Vec<String>>,
11986    description__empty: Option<bool>,
11987    description__ic: Option<Vec<String>>,
11988    description__ie: Option<Vec<String>>,
11989    description__iew: Option<Vec<String>>,
11990    description__iregex: Option<Vec<String>>,
11991    description__isw: Option<Vec<String>>,
11992    description__n: Option<Vec<String>>,
11993    description__nic: Option<Vec<String>>,
11994    description__nie: Option<Vec<String>>,
11995    description__niew: Option<Vec<String>>,
11996    description__nisw: Option<Vec<String>>,
11997    description__regex: Option<Vec<String>>,
11998    device: Option<Vec<String>>,
11999    device__n: Option<Vec<String>>,
12000    device_id: Option<Vec<i32>>,
12001    device_id__n: Option<Vec<i32>>,
12002    disk: Option<Vec<i32>>,
12003    disk__empty: Option<bool>,
12004    disk__gt: Option<Vec<i32>>,
12005    disk__gte: Option<Vec<i32>>,
12006    disk__lt: Option<Vec<i32>>,
12007    disk__lte: Option<Vec<i32>>,
12008    disk__n: Option<Vec<i32>>,
12009    has_primary_ip: Option<bool>,
12010    id: Option<Vec<i32>>,
12011    id__empty: Option<bool>,
12012    id__gt: Option<Vec<i32>>,
12013    id__gte: Option<Vec<i32>>,
12014    id__lt: Option<Vec<i32>>,
12015    id__lte: Option<Vec<i32>>,
12016    id__n: Option<Vec<i32>>,
12017    interface_count: Option<Vec<i32>>,
12018    interface_count__empty: Option<bool>,
12019    interface_count__gt: Option<Vec<i32>>,
12020    interface_count__gte: Option<Vec<i32>>,
12021    interface_count__lt: Option<Vec<i32>>,
12022    interface_count__lte: Option<Vec<i32>>,
12023    interface_count__n: Option<Vec<i32>>,
12024    last_updated: Option<Vec<String>>,
12025    last_updated__empty: Option<Vec<String>>,
12026    last_updated__gt: Option<Vec<String>>,
12027    last_updated__gte: Option<Vec<String>>,
12028    last_updated__lt: Option<Vec<String>>,
12029    last_updated__lte: Option<Vec<String>>,
12030    last_updated__n: Option<Vec<String>>,
12031    limit: Option<i32>,
12032    local_context_data: Option<bool>,
12033    mac_address: Option<Vec<String>>,
12034    mac_address__ic: Option<Vec<String>>,
12035    mac_address__ie: Option<Vec<String>>,
12036    mac_address__iew: Option<Vec<String>>,
12037    mac_address__iregex: Option<Vec<String>>,
12038    mac_address__isw: Option<Vec<String>>,
12039    mac_address__n: Option<Vec<String>>,
12040    mac_address__nic: Option<Vec<String>>,
12041    mac_address__nie: Option<Vec<String>>,
12042    mac_address__niew: Option<Vec<String>>,
12043    mac_address__nisw: Option<Vec<String>>,
12044    mac_address__regex: Option<Vec<String>>,
12045    memory: Option<Vec<i32>>,
12046    memory__empty: Option<bool>,
12047    memory__gt: Option<Vec<i32>>,
12048    memory__gte: Option<Vec<i32>>,
12049    memory__lt: Option<Vec<i32>>,
12050    memory__lte: Option<Vec<i32>>,
12051    memory__n: Option<Vec<i32>>,
12052    modified_by_request: Option<&str>,
12053    name: Option<Vec<String>>,
12054    name__empty: Option<bool>,
12055    name__ic: Option<Vec<String>>,
12056    name__ie: Option<Vec<String>>,
12057    name__iew: Option<Vec<String>>,
12058    name__iregex: Option<Vec<String>>,
12059    name__isw: Option<Vec<String>>,
12060    name__n: Option<Vec<String>>,
12061    name__nic: Option<Vec<String>>,
12062    name__nie: Option<Vec<String>>,
12063    name__niew: Option<Vec<String>>,
12064    name__nisw: Option<Vec<String>>,
12065    name__regex: Option<Vec<String>>,
12066    offset: Option<i32>,
12067    ordering: Option<&str>,
12068    owner: Option<Vec<String>>,
12069    owner__n: Option<Vec<String>>,
12070    owner_group: Option<Vec<String>>,
12071    owner_group__n: Option<Vec<String>>,
12072    owner_group_id: Option<Vec<i32>>,
12073    owner_group_id__n: Option<Vec<i32>>,
12074    owner_id: Option<Vec<i32>>,
12075    owner_id__n: Option<Vec<i32>>,
12076    platform: Option<Vec<String>>,
12077    platform__n: Option<Vec<String>>,
12078    platform_id: Option<Vec<String>>,
12079    platform_id__n: Option<Vec<String>>,
12080    primary_ip4: Option<Vec<String>>,
12081    primary_ip4__n: Option<Vec<String>>,
12082    primary_ip4_id: Option<Vec<i32>>,
12083    primary_ip4_id__n: Option<Vec<i32>>,
12084    primary_ip6: Option<Vec<String>>,
12085    primary_ip6__n: Option<Vec<String>>,
12086    primary_ip6_id: Option<Vec<i32>>,
12087    primary_ip6_id__n: Option<Vec<i32>>,
12088    q: Option<&str>,
12089    region: Option<Vec<String>>,
12090    region__n: Option<Vec<String>>,
12091    region_id: Option<Vec<String>>,
12092    region_id__n: Option<Vec<String>>,
12093    role: Option<Vec<String>>,
12094    role__n: Option<Vec<String>>,
12095    role_id: Option<Vec<String>>,
12096    role_id__n: Option<Vec<String>>,
12097    serial: Option<Vec<String>>,
12098    serial__empty: Option<bool>,
12099    serial__ic: Option<Vec<String>>,
12100    serial__ie: Option<Vec<String>>,
12101    serial__iew: Option<Vec<String>>,
12102    serial__iregex: Option<Vec<String>>,
12103    serial__isw: Option<Vec<String>>,
12104    serial__n: Option<Vec<String>>,
12105    serial__nic: Option<Vec<String>>,
12106    serial__nie: Option<Vec<String>>,
12107    serial__niew: Option<Vec<String>>,
12108    serial__nisw: Option<Vec<String>>,
12109    serial__regex: Option<Vec<String>>,
12110    site: Option<Vec<String>>,
12111    site__n: Option<Vec<String>>,
12112    site_group: Option<Vec<String>>,
12113    site_group__n: Option<Vec<String>>,
12114    site_group_id: Option<Vec<String>>,
12115    site_group_id__n: Option<Vec<String>>,
12116    site_id: Option<Vec<i32>>,
12117    site_id__n: Option<Vec<i32>>,
12118    start_on_boot: Option<Vec<String>>,
12119    start_on_boot__empty: Option<bool>,
12120    start_on_boot__ic: Option<Vec<String>>,
12121    start_on_boot__ie: Option<Vec<String>>,
12122    start_on_boot__iew: Option<Vec<String>>,
12123    start_on_boot__iregex: Option<Vec<String>>,
12124    start_on_boot__isw: Option<Vec<String>>,
12125    start_on_boot__n: Option<Vec<String>>,
12126    start_on_boot__nic: Option<Vec<String>>,
12127    start_on_boot__nie: Option<Vec<String>>,
12128    start_on_boot__niew: Option<Vec<String>>,
12129    start_on_boot__nisw: Option<Vec<String>>,
12130    start_on_boot__regex: Option<Vec<String>>,
12131    status: Option<Vec<String>>,
12132    status__empty: Option<bool>,
12133    status__ic: Option<Vec<String>>,
12134    status__ie: Option<Vec<String>>,
12135    status__iew: Option<Vec<String>>,
12136    status__iregex: Option<Vec<String>>,
12137    status__isw: Option<Vec<String>>,
12138    status__n: Option<Vec<String>>,
12139    status__nic: Option<Vec<String>>,
12140    status__nie: Option<Vec<String>>,
12141    status__niew: Option<Vec<String>>,
12142    status__nisw: Option<Vec<String>>,
12143    status__regex: Option<Vec<String>>,
12144    tag: Option<Vec<String>>,
12145    tag__n: Option<Vec<String>>,
12146    tag_id: Option<Vec<i32>>,
12147    tag_id__n: Option<Vec<i32>>,
12148    tenant: Option<Vec<String>>,
12149    tenant__n: Option<Vec<String>>,
12150    tenant_group: Option<Vec<String>>,
12151    tenant_group__n: Option<Vec<String>>,
12152    tenant_group_id: Option<Vec<String>>,
12153    tenant_group_id__n: Option<Vec<String>>,
12154    tenant_id: Option<Vec<i32>>,
12155    tenant_id__n: Option<Vec<i32>>,
12156    updated_by_request: Option<&str>,
12157    vcpus: Option<Vec<f64>>,
12158    vcpus__empty: Option<bool>,
12159    vcpus__gt: Option<Vec<f64>>,
12160    vcpus__gte: Option<Vec<f64>>,
12161    vcpus__lt: Option<Vec<f64>>,
12162    vcpus__lte: Option<Vec<f64>>,
12163    vcpus__n: Option<Vec<f64>>,
12164    virtual_disk_count: Option<Vec<i32>>,
12165    virtual_disk_count__empty: Option<bool>,
12166    virtual_disk_count__gt: Option<Vec<i32>>,
12167    virtual_disk_count__gte: Option<Vec<i32>>,
12168    virtual_disk_count__lt: Option<Vec<i32>>,
12169    virtual_disk_count__lte: Option<Vec<i32>>,
12170    virtual_disk_count__n: Option<Vec<i32>>,
12171) -> Result<
12172    crate::models::PaginatedVirtualMachineWithConfigContextList,
12173    Error<VirtualizationVirtualMachinesListError>,
12174> {
12175    let local_var_configuration = configuration;
12176
12177    let local_var_client = &local_var_configuration.client;
12178
12179    let local_var_uri_str = format!(
12180        "{}/api/virtualization/virtual-machines/",
12181        local_var_configuration.base_path
12182    );
12183    let mut local_var_req_builder =
12184        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12185
12186    if let Some(ref local_var_str) = cluster {
12187        local_var_req_builder = match "multi" {
12188            "multi" => local_var_req_builder.query(
12189                &local_var_str
12190                    .into_iter()
12191                    .map(|p| ("cluster".to_owned(), p.to_string()))
12192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12193            ),
12194            _ => local_var_req_builder.query(&[(
12195                "cluster",
12196                &local_var_str
12197                    .into_iter()
12198                    .map(|p| p.to_string())
12199                    .collect::<Vec<String>>()
12200                    .join(",")
12201                    .to_string(),
12202            )]),
12203        };
12204    }
12205    if let Some(ref local_var_str) = cluster__n {
12206        local_var_req_builder = match "multi" {
12207            "multi" => local_var_req_builder.query(
12208                &local_var_str
12209                    .into_iter()
12210                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
12211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12212            ),
12213            _ => local_var_req_builder.query(&[(
12214                "cluster__n",
12215                &local_var_str
12216                    .into_iter()
12217                    .map(|p| p.to_string())
12218                    .collect::<Vec<String>>()
12219                    .join(",")
12220                    .to_string(),
12221            )]),
12222        };
12223    }
12224    if let Some(ref local_var_str) = cluster_group {
12225        local_var_req_builder = match "multi" {
12226            "multi" => local_var_req_builder.query(
12227                &local_var_str
12228                    .into_iter()
12229                    .map(|p| ("cluster_group".to_owned(), p.to_string()))
12230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12231            ),
12232            _ => local_var_req_builder.query(&[(
12233                "cluster_group",
12234                &local_var_str
12235                    .into_iter()
12236                    .map(|p| p.to_string())
12237                    .collect::<Vec<String>>()
12238                    .join(",")
12239                    .to_string(),
12240            )]),
12241        };
12242    }
12243    if let Some(ref local_var_str) = cluster_group__n {
12244        local_var_req_builder = match "multi" {
12245            "multi" => local_var_req_builder.query(
12246                &local_var_str
12247                    .into_iter()
12248                    .map(|p| ("cluster_group__n".to_owned(), p.to_string()))
12249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12250            ),
12251            _ => local_var_req_builder.query(&[(
12252                "cluster_group__n",
12253                &local_var_str
12254                    .into_iter()
12255                    .map(|p| p.to_string())
12256                    .collect::<Vec<String>>()
12257                    .join(",")
12258                    .to_string(),
12259            )]),
12260        };
12261    }
12262    if let Some(ref local_var_str) = cluster_group_id {
12263        local_var_req_builder = match "multi" {
12264            "multi" => local_var_req_builder.query(
12265                &local_var_str
12266                    .into_iter()
12267                    .map(|p| ("cluster_group_id".to_owned(), p.to_string()))
12268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12269            ),
12270            _ => local_var_req_builder.query(&[(
12271                "cluster_group_id",
12272                &local_var_str
12273                    .into_iter()
12274                    .map(|p| p.to_string())
12275                    .collect::<Vec<String>>()
12276                    .join(",")
12277                    .to_string(),
12278            )]),
12279        };
12280    }
12281    if let Some(ref local_var_str) = cluster_group_id__n {
12282        local_var_req_builder = match "multi" {
12283            "multi" => local_var_req_builder.query(
12284                &local_var_str
12285                    .into_iter()
12286                    .map(|p| ("cluster_group_id__n".to_owned(), p.to_string()))
12287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12288            ),
12289            _ => local_var_req_builder.query(&[(
12290                "cluster_group_id__n",
12291                &local_var_str
12292                    .into_iter()
12293                    .map(|p| p.to_string())
12294                    .collect::<Vec<String>>()
12295                    .join(",")
12296                    .to_string(),
12297            )]),
12298        };
12299    }
12300    if let Some(ref local_var_str) = cluster_id {
12301        local_var_req_builder = match "multi" {
12302            "multi" => local_var_req_builder.query(
12303                &local_var_str
12304                    .into_iter()
12305                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
12306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12307            ),
12308            _ => local_var_req_builder.query(&[(
12309                "cluster_id",
12310                &local_var_str
12311                    .into_iter()
12312                    .map(|p| p.to_string())
12313                    .collect::<Vec<String>>()
12314                    .join(",")
12315                    .to_string(),
12316            )]),
12317        };
12318    }
12319    if let Some(ref local_var_str) = cluster_id__n {
12320        local_var_req_builder = match "multi" {
12321            "multi" => local_var_req_builder.query(
12322                &local_var_str
12323                    .into_iter()
12324                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
12325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12326            ),
12327            _ => local_var_req_builder.query(&[(
12328                "cluster_id__n",
12329                &local_var_str
12330                    .into_iter()
12331                    .map(|p| p.to_string())
12332                    .collect::<Vec<String>>()
12333                    .join(",")
12334                    .to_string(),
12335            )]),
12336        };
12337    }
12338    if let Some(ref local_var_str) = cluster_type {
12339        local_var_req_builder = match "multi" {
12340            "multi" => local_var_req_builder.query(
12341                &local_var_str
12342                    .into_iter()
12343                    .map(|p| ("cluster_type".to_owned(), p.to_string()))
12344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12345            ),
12346            _ => local_var_req_builder.query(&[(
12347                "cluster_type",
12348                &local_var_str
12349                    .into_iter()
12350                    .map(|p| p.to_string())
12351                    .collect::<Vec<String>>()
12352                    .join(",")
12353                    .to_string(),
12354            )]),
12355        };
12356    }
12357    if let Some(ref local_var_str) = cluster_type__n {
12358        local_var_req_builder = match "multi" {
12359            "multi" => local_var_req_builder.query(
12360                &local_var_str
12361                    .into_iter()
12362                    .map(|p| ("cluster_type__n".to_owned(), p.to_string()))
12363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12364            ),
12365            _ => local_var_req_builder.query(&[(
12366                "cluster_type__n",
12367                &local_var_str
12368                    .into_iter()
12369                    .map(|p| p.to_string())
12370                    .collect::<Vec<String>>()
12371                    .join(",")
12372                    .to_string(),
12373            )]),
12374        };
12375    }
12376    if let Some(ref local_var_str) = cluster_type_id {
12377        local_var_req_builder = match "multi" {
12378            "multi" => local_var_req_builder.query(
12379                &local_var_str
12380                    .into_iter()
12381                    .map(|p| ("cluster_type_id".to_owned(), p.to_string()))
12382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12383            ),
12384            _ => local_var_req_builder.query(&[(
12385                "cluster_type_id",
12386                &local_var_str
12387                    .into_iter()
12388                    .map(|p| p.to_string())
12389                    .collect::<Vec<String>>()
12390                    .join(",")
12391                    .to_string(),
12392            )]),
12393        };
12394    }
12395    if let Some(ref local_var_str) = cluster_type_id__n {
12396        local_var_req_builder = match "multi" {
12397            "multi" => local_var_req_builder.query(
12398                &local_var_str
12399                    .into_iter()
12400                    .map(|p| ("cluster_type_id__n".to_owned(), p.to_string()))
12401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12402            ),
12403            _ => local_var_req_builder.query(&[(
12404                "cluster_type_id__n",
12405                &local_var_str
12406                    .into_iter()
12407                    .map(|p| p.to_string())
12408                    .collect::<Vec<String>>()
12409                    .join(",")
12410                    .to_string(),
12411            )]),
12412        };
12413    }
12414    if let Some(ref local_var_str) = config_template_id {
12415        local_var_req_builder = match "multi" {
12416            "multi" => local_var_req_builder.query(
12417                &local_var_str
12418                    .into_iter()
12419                    .map(|p| ("config_template_id".to_owned(), p.to_string()))
12420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12421            ),
12422            _ => local_var_req_builder.query(&[(
12423                "config_template_id",
12424                &local_var_str
12425                    .into_iter()
12426                    .map(|p| p.to_string())
12427                    .collect::<Vec<String>>()
12428                    .join(",")
12429                    .to_string(),
12430            )]),
12431        };
12432    }
12433    if let Some(ref local_var_str) = config_template_id__n {
12434        local_var_req_builder = match "multi" {
12435            "multi" => local_var_req_builder.query(
12436                &local_var_str
12437                    .into_iter()
12438                    .map(|p| ("config_template_id__n".to_owned(), p.to_string()))
12439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12440            ),
12441            _ => local_var_req_builder.query(&[(
12442                "config_template_id__n",
12443                &local_var_str
12444                    .into_iter()
12445                    .map(|p| p.to_string())
12446                    .collect::<Vec<String>>()
12447                    .join(",")
12448                    .to_string(),
12449            )]),
12450        };
12451    }
12452    if let Some(ref local_var_str) = contact {
12453        local_var_req_builder = match "multi" {
12454            "multi" => local_var_req_builder.query(
12455                &local_var_str
12456                    .into_iter()
12457                    .map(|p| ("contact".to_owned(), p.to_string()))
12458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12459            ),
12460            _ => local_var_req_builder.query(&[(
12461                "contact",
12462                &local_var_str
12463                    .into_iter()
12464                    .map(|p| p.to_string())
12465                    .collect::<Vec<String>>()
12466                    .join(",")
12467                    .to_string(),
12468            )]),
12469        };
12470    }
12471    if let Some(ref local_var_str) = contact__n {
12472        local_var_req_builder = match "multi" {
12473            "multi" => local_var_req_builder.query(
12474                &local_var_str
12475                    .into_iter()
12476                    .map(|p| ("contact__n".to_owned(), p.to_string()))
12477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12478            ),
12479            _ => local_var_req_builder.query(&[(
12480                "contact__n",
12481                &local_var_str
12482                    .into_iter()
12483                    .map(|p| p.to_string())
12484                    .collect::<Vec<String>>()
12485                    .join(",")
12486                    .to_string(),
12487            )]),
12488        };
12489    }
12490    if let Some(ref local_var_str) = contact_group {
12491        local_var_req_builder = match "multi" {
12492            "multi" => local_var_req_builder.query(
12493                &local_var_str
12494                    .into_iter()
12495                    .map(|p| ("contact_group".to_owned(), p.to_string()))
12496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12497            ),
12498            _ => local_var_req_builder.query(&[(
12499                "contact_group",
12500                &local_var_str
12501                    .into_iter()
12502                    .map(|p| p.to_string())
12503                    .collect::<Vec<String>>()
12504                    .join(",")
12505                    .to_string(),
12506            )]),
12507        };
12508    }
12509    if let Some(ref local_var_str) = contact_group__n {
12510        local_var_req_builder = match "multi" {
12511            "multi" => local_var_req_builder.query(
12512                &local_var_str
12513                    .into_iter()
12514                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
12515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12516            ),
12517            _ => local_var_req_builder.query(&[(
12518                "contact_group__n",
12519                &local_var_str
12520                    .into_iter()
12521                    .map(|p| p.to_string())
12522                    .collect::<Vec<String>>()
12523                    .join(",")
12524                    .to_string(),
12525            )]),
12526        };
12527    }
12528    if let Some(ref local_var_str) = contact_role {
12529        local_var_req_builder = match "multi" {
12530            "multi" => local_var_req_builder.query(
12531                &local_var_str
12532                    .into_iter()
12533                    .map(|p| ("contact_role".to_owned(), p.to_string()))
12534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12535            ),
12536            _ => local_var_req_builder.query(&[(
12537                "contact_role",
12538                &local_var_str
12539                    .into_iter()
12540                    .map(|p| p.to_string())
12541                    .collect::<Vec<String>>()
12542                    .join(",")
12543                    .to_string(),
12544            )]),
12545        };
12546    }
12547    if let Some(ref local_var_str) = contact_role__n {
12548        local_var_req_builder = match "multi" {
12549            "multi" => local_var_req_builder.query(
12550                &local_var_str
12551                    .into_iter()
12552                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
12553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12554            ),
12555            _ => local_var_req_builder.query(&[(
12556                "contact_role__n",
12557                &local_var_str
12558                    .into_iter()
12559                    .map(|p| p.to_string())
12560                    .collect::<Vec<String>>()
12561                    .join(",")
12562                    .to_string(),
12563            )]),
12564        };
12565    }
12566    if let Some(ref local_var_str) = created {
12567        local_var_req_builder = match "multi" {
12568            "multi" => local_var_req_builder.query(
12569                &local_var_str
12570                    .into_iter()
12571                    .map(|p| ("created".to_owned(), p.to_string()))
12572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12573            ),
12574            _ => local_var_req_builder.query(&[(
12575                "created",
12576                &local_var_str
12577                    .into_iter()
12578                    .map(|p| p.to_string())
12579                    .collect::<Vec<String>>()
12580                    .join(",")
12581                    .to_string(),
12582            )]),
12583        };
12584    }
12585    if let Some(ref local_var_str) = created__empty {
12586        local_var_req_builder = match "multi" {
12587            "multi" => local_var_req_builder.query(
12588                &local_var_str
12589                    .into_iter()
12590                    .map(|p| ("created__empty".to_owned(), p.to_string()))
12591                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12592            ),
12593            _ => local_var_req_builder.query(&[(
12594                "created__empty",
12595                &local_var_str
12596                    .into_iter()
12597                    .map(|p| p.to_string())
12598                    .collect::<Vec<String>>()
12599                    .join(",")
12600                    .to_string(),
12601            )]),
12602        };
12603    }
12604    if let Some(ref local_var_str) = created__gt {
12605        local_var_req_builder = match "multi" {
12606            "multi" => local_var_req_builder.query(
12607                &local_var_str
12608                    .into_iter()
12609                    .map(|p| ("created__gt".to_owned(), p.to_string()))
12610                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12611            ),
12612            _ => local_var_req_builder.query(&[(
12613                "created__gt",
12614                &local_var_str
12615                    .into_iter()
12616                    .map(|p| p.to_string())
12617                    .collect::<Vec<String>>()
12618                    .join(",")
12619                    .to_string(),
12620            )]),
12621        };
12622    }
12623    if let Some(ref local_var_str) = created__gte {
12624        local_var_req_builder = match "multi" {
12625            "multi" => local_var_req_builder.query(
12626                &local_var_str
12627                    .into_iter()
12628                    .map(|p| ("created__gte".to_owned(), p.to_string()))
12629                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12630            ),
12631            _ => local_var_req_builder.query(&[(
12632                "created__gte",
12633                &local_var_str
12634                    .into_iter()
12635                    .map(|p| p.to_string())
12636                    .collect::<Vec<String>>()
12637                    .join(",")
12638                    .to_string(),
12639            )]),
12640        };
12641    }
12642    if let Some(ref local_var_str) = created__lt {
12643        local_var_req_builder = match "multi" {
12644            "multi" => local_var_req_builder.query(
12645                &local_var_str
12646                    .into_iter()
12647                    .map(|p| ("created__lt".to_owned(), p.to_string()))
12648                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12649            ),
12650            _ => local_var_req_builder.query(&[(
12651                "created__lt",
12652                &local_var_str
12653                    .into_iter()
12654                    .map(|p| p.to_string())
12655                    .collect::<Vec<String>>()
12656                    .join(",")
12657                    .to_string(),
12658            )]),
12659        };
12660    }
12661    if let Some(ref local_var_str) = created__lte {
12662        local_var_req_builder = match "multi" {
12663            "multi" => local_var_req_builder.query(
12664                &local_var_str
12665                    .into_iter()
12666                    .map(|p| ("created__lte".to_owned(), p.to_string()))
12667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12668            ),
12669            _ => local_var_req_builder.query(&[(
12670                "created__lte",
12671                &local_var_str
12672                    .into_iter()
12673                    .map(|p| p.to_string())
12674                    .collect::<Vec<String>>()
12675                    .join(",")
12676                    .to_string(),
12677            )]),
12678        };
12679    }
12680    if let Some(ref local_var_str) = created__n {
12681        local_var_req_builder = match "multi" {
12682            "multi" => local_var_req_builder.query(
12683                &local_var_str
12684                    .into_iter()
12685                    .map(|p| ("created__n".to_owned(), p.to_string()))
12686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12687            ),
12688            _ => local_var_req_builder.query(&[(
12689                "created__n",
12690                &local_var_str
12691                    .into_iter()
12692                    .map(|p| p.to_string())
12693                    .collect::<Vec<String>>()
12694                    .join(",")
12695                    .to_string(),
12696            )]),
12697        };
12698    }
12699    if let Some(ref local_var_str) = created_by_request {
12700        local_var_req_builder =
12701            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
12702    }
12703    if let Some(ref local_var_str) = description {
12704        local_var_req_builder = match "multi" {
12705            "multi" => local_var_req_builder.query(
12706                &local_var_str
12707                    .into_iter()
12708                    .map(|p| ("description".to_owned(), p.to_string()))
12709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12710            ),
12711            _ => local_var_req_builder.query(&[(
12712                "description",
12713                &local_var_str
12714                    .into_iter()
12715                    .map(|p| p.to_string())
12716                    .collect::<Vec<String>>()
12717                    .join(",")
12718                    .to_string(),
12719            )]),
12720        };
12721    }
12722    if let Some(ref local_var_str) = description__empty {
12723        local_var_req_builder =
12724            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
12725    }
12726    if let Some(ref local_var_str) = description__ic {
12727        local_var_req_builder = match "multi" {
12728            "multi" => local_var_req_builder.query(
12729                &local_var_str
12730                    .into_iter()
12731                    .map(|p| ("description__ic".to_owned(), p.to_string()))
12732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12733            ),
12734            _ => local_var_req_builder.query(&[(
12735                "description__ic",
12736                &local_var_str
12737                    .into_iter()
12738                    .map(|p| p.to_string())
12739                    .collect::<Vec<String>>()
12740                    .join(",")
12741                    .to_string(),
12742            )]),
12743        };
12744    }
12745    if let Some(ref local_var_str) = description__ie {
12746        local_var_req_builder = match "multi" {
12747            "multi" => local_var_req_builder.query(
12748                &local_var_str
12749                    .into_iter()
12750                    .map(|p| ("description__ie".to_owned(), p.to_string()))
12751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12752            ),
12753            _ => local_var_req_builder.query(&[(
12754                "description__ie",
12755                &local_var_str
12756                    .into_iter()
12757                    .map(|p| p.to_string())
12758                    .collect::<Vec<String>>()
12759                    .join(",")
12760                    .to_string(),
12761            )]),
12762        };
12763    }
12764    if let Some(ref local_var_str) = description__iew {
12765        local_var_req_builder = match "multi" {
12766            "multi" => local_var_req_builder.query(
12767                &local_var_str
12768                    .into_iter()
12769                    .map(|p| ("description__iew".to_owned(), p.to_string()))
12770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12771            ),
12772            _ => local_var_req_builder.query(&[(
12773                "description__iew",
12774                &local_var_str
12775                    .into_iter()
12776                    .map(|p| p.to_string())
12777                    .collect::<Vec<String>>()
12778                    .join(",")
12779                    .to_string(),
12780            )]),
12781        };
12782    }
12783    if let Some(ref local_var_str) = description__iregex {
12784        local_var_req_builder = match "multi" {
12785            "multi" => local_var_req_builder.query(
12786                &local_var_str
12787                    .into_iter()
12788                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
12789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12790            ),
12791            _ => local_var_req_builder.query(&[(
12792                "description__iregex",
12793                &local_var_str
12794                    .into_iter()
12795                    .map(|p| p.to_string())
12796                    .collect::<Vec<String>>()
12797                    .join(",")
12798                    .to_string(),
12799            )]),
12800        };
12801    }
12802    if let Some(ref local_var_str) = description__isw {
12803        local_var_req_builder = match "multi" {
12804            "multi" => local_var_req_builder.query(
12805                &local_var_str
12806                    .into_iter()
12807                    .map(|p| ("description__isw".to_owned(), p.to_string()))
12808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12809            ),
12810            _ => local_var_req_builder.query(&[(
12811                "description__isw",
12812                &local_var_str
12813                    .into_iter()
12814                    .map(|p| p.to_string())
12815                    .collect::<Vec<String>>()
12816                    .join(",")
12817                    .to_string(),
12818            )]),
12819        };
12820    }
12821    if let Some(ref local_var_str) = description__n {
12822        local_var_req_builder = match "multi" {
12823            "multi" => local_var_req_builder.query(
12824                &local_var_str
12825                    .into_iter()
12826                    .map(|p| ("description__n".to_owned(), p.to_string()))
12827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12828            ),
12829            _ => local_var_req_builder.query(&[(
12830                "description__n",
12831                &local_var_str
12832                    .into_iter()
12833                    .map(|p| p.to_string())
12834                    .collect::<Vec<String>>()
12835                    .join(",")
12836                    .to_string(),
12837            )]),
12838        };
12839    }
12840    if let Some(ref local_var_str) = description__nic {
12841        local_var_req_builder = match "multi" {
12842            "multi" => local_var_req_builder.query(
12843                &local_var_str
12844                    .into_iter()
12845                    .map(|p| ("description__nic".to_owned(), p.to_string()))
12846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12847            ),
12848            _ => local_var_req_builder.query(&[(
12849                "description__nic",
12850                &local_var_str
12851                    .into_iter()
12852                    .map(|p| p.to_string())
12853                    .collect::<Vec<String>>()
12854                    .join(",")
12855                    .to_string(),
12856            )]),
12857        };
12858    }
12859    if let Some(ref local_var_str) = description__nie {
12860        local_var_req_builder = match "multi" {
12861            "multi" => local_var_req_builder.query(
12862                &local_var_str
12863                    .into_iter()
12864                    .map(|p| ("description__nie".to_owned(), p.to_string()))
12865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12866            ),
12867            _ => local_var_req_builder.query(&[(
12868                "description__nie",
12869                &local_var_str
12870                    .into_iter()
12871                    .map(|p| p.to_string())
12872                    .collect::<Vec<String>>()
12873                    .join(",")
12874                    .to_string(),
12875            )]),
12876        };
12877    }
12878    if let Some(ref local_var_str) = description__niew {
12879        local_var_req_builder = match "multi" {
12880            "multi" => local_var_req_builder.query(
12881                &local_var_str
12882                    .into_iter()
12883                    .map(|p| ("description__niew".to_owned(), p.to_string()))
12884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12885            ),
12886            _ => local_var_req_builder.query(&[(
12887                "description__niew",
12888                &local_var_str
12889                    .into_iter()
12890                    .map(|p| p.to_string())
12891                    .collect::<Vec<String>>()
12892                    .join(",")
12893                    .to_string(),
12894            )]),
12895        };
12896    }
12897    if let Some(ref local_var_str) = description__nisw {
12898        local_var_req_builder = match "multi" {
12899            "multi" => local_var_req_builder.query(
12900                &local_var_str
12901                    .into_iter()
12902                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
12903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12904            ),
12905            _ => local_var_req_builder.query(&[(
12906                "description__nisw",
12907                &local_var_str
12908                    .into_iter()
12909                    .map(|p| p.to_string())
12910                    .collect::<Vec<String>>()
12911                    .join(",")
12912                    .to_string(),
12913            )]),
12914        };
12915    }
12916    if let Some(ref local_var_str) = description__regex {
12917        local_var_req_builder = match "multi" {
12918            "multi" => local_var_req_builder.query(
12919                &local_var_str
12920                    .into_iter()
12921                    .map(|p| ("description__regex".to_owned(), p.to_string()))
12922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12923            ),
12924            _ => local_var_req_builder.query(&[(
12925                "description__regex",
12926                &local_var_str
12927                    .into_iter()
12928                    .map(|p| p.to_string())
12929                    .collect::<Vec<String>>()
12930                    .join(",")
12931                    .to_string(),
12932            )]),
12933        };
12934    }
12935    if let Some(ref local_var_str) = device {
12936        local_var_req_builder = match "multi" {
12937            "multi" => local_var_req_builder.query(
12938                &local_var_str
12939                    .into_iter()
12940                    .map(|p| ("device".to_owned(), p.to_string()))
12941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12942            ),
12943            _ => local_var_req_builder.query(&[(
12944                "device",
12945                &local_var_str
12946                    .into_iter()
12947                    .map(|p| p.to_string())
12948                    .collect::<Vec<String>>()
12949                    .join(",")
12950                    .to_string(),
12951            )]),
12952        };
12953    }
12954    if let Some(ref local_var_str) = device__n {
12955        local_var_req_builder = match "multi" {
12956            "multi" => local_var_req_builder.query(
12957                &local_var_str
12958                    .into_iter()
12959                    .map(|p| ("device__n".to_owned(), p.to_string()))
12960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12961            ),
12962            _ => local_var_req_builder.query(&[(
12963                "device__n",
12964                &local_var_str
12965                    .into_iter()
12966                    .map(|p| p.to_string())
12967                    .collect::<Vec<String>>()
12968                    .join(",")
12969                    .to_string(),
12970            )]),
12971        };
12972    }
12973    if let Some(ref local_var_str) = device_id {
12974        local_var_req_builder = match "multi" {
12975            "multi" => local_var_req_builder.query(
12976                &local_var_str
12977                    .into_iter()
12978                    .map(|p| ("device_id".to_owned(), p.to_string()))
12979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12980            ),
12981            _ => local_var_req_builder.query(&[(
12982                "device_id",
12983                &local_var_str
12984                    .into_iter()
12985                    .map(|p| p.to_string())
12986                    .collect::<Vec<String>>()
12987                    .join(",")
12988                    .to_string(),
12989            )]),
12990        };
12991    }
12992    if let Some(ref local_var_str) = device_id__n {
12993        local_var_req_builder = match "multi" {
12994            "multi" => local_var_req_builder.query(
12995                &local_var_str
12996                    .into_iter()
12997                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
12998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12999            ),
13000            _ => local_var_req_builder.query(&[(
13001                "device_id__n",
13002                &local_var_str
13003                    .into_iter()
13004                    .map(|p| p.to_string())
13005                    .collect::<Vec<String>>()
13006                    .join(",")
13007                    .to_string(),
13008            )]),
13009        };
13010    }
13011    if let Some(ref local_var_str) = disk {
13012        local_var_req_builder = match "multi" {
13013            "multi" => local_var_req_builder.query(
13014                &local_var_str
13015                    .into_iter()
13016                    .map(|p| ("disk".to_owned(), p.to_string()))
13017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13018            ),
13019            _ => local_var_req_builder.query(&[(
13020                "disk",
13021                &local_var_str
13022                    .into_iter()
13023                    .map(|p| p.to_string())
13024                    .collect::<Vec<String>>()
13025                    .join(",")
13026                    .to_string(),
13027            )]),
13028        };
13029    }
13030    if let Some(ref local_var_str) = disk__empty {
13031        local_var_req_builder =
13032            local_var_req_builder.query(&[("disk__empty", &local_var_str.to_string())]);
13033    }
13034    if let Some(ref local_var_str) = disk__gt {
13035        local_var_req_builder = match "multi" {
13036            "multi" => local_var_req_builder.query(
13037                &local_var_str
13038                    .into_iter()
13039                    .map(|p| ("disk__gt".to_owned(), p.to_string()))
13040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13041            ),
13042            _ => local_var_req_builder.query(&[(
13043                "disk__gt",
13044                &local_var_str
13045                    .into_iter()
13046                    .map(|p| p.to_string())
13047                    .collect::<Vec<String>>()
13048                    .join(",")
13049                    .to_string(),
13050            )]),
13051        };
13052    }
13053    if let Some(ref local_var_str) = disk__gte {
13054        local_var_req_builder = match "multi" {
13055            "multi" => local_var_req_builder.query(
13056                &local_var_str
13057                    .into_iter()
13058                    .map(|p| ("disk__gte".to_owned(), p.to_string()))
13059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13060            ),
13061            _ => local_var_req_builder.query(&[(
13062                "disk__gte",
13063                &local_var_str
13064                    .into_iter()
13065                    .map(|p| p.to_string())
13066                    .collect::<Vec<String>>()
13067                    .join(",")
13068                    .to_string(),
13069            )]),
13070        };
13071    }
13072    if let Some(ref local_var_str) = disk__lt {
13073        local_var_req_builder = match "multi" {
13074            "multi" => local_var_req_builder.query(
13075                &local_var_str
13076                    .into_iter()
13077                    .map(|p| ("disk__lt".to_owned(), p.to_string()))
13078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13079            ),
13080            _ => local_var_req_builder.query(&[(
13081                "disk__lt",
13082                &local_var_str
13083                    .into_iter()
13084                    .map(|p| p.to_string())
13085                    .collect::<Vec<String>>()
13086                    .join(",")
13087                    .to_string(),
13088            )]),
13089        };
13090    }
13091    if let Some(ref local_var_str) = disk__lte {
13092        local_var_req_builder = match "multi" {
13093            "multi" => local_var_req_builder.query(
13094                &local_var_str
13095                    .into_iter()
13096                    .map(|p| ("disk__lte".to_owned(), p.to_string()))
13097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13098            ),
13099            _ => local_var_req_builder.query(&[(
13100                "disk__lte",
13101                &local_var_str
13102                    .into_iter()
13103                    .map(|p| p.to_string())
13104                    .collect::<Vec<String>>()
13105                    .join(",")
13106                    .to_string(),
13107            )]),
13108        };
13109    }
13110    if let Some(ref local_var_str) = disk__n {
13111        local_var_req_builder = match "multi" {
13112            "multi" => local_var_req_builder.query(
13113                &local_var_str
13114                    .into_iter()
13115                    .map(|p| ("disk__n".to_owned(), p.to_string()))
13116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13117            ),
13118            _ => local_var_req_builder.query(&[(
13119                "disk__n",
13120                &local_var_str
13121                    .into_iter()
13122                    .map(|p| p.to_string())
13123                    .collect::<Vec<String>>()
13124                    .join(",")
13125                    .to_string(),
13126            )]),
13127        };
13128    }
13129    if let Some(ref local_var_str) = has_primary_ip {
13130        local_var_req_builder =
13131            local_var_req_builder.query(&[("has_primary_ip", &local_var_str.to_string())]);
13132    }
13133    if let Some(ref local_var_str) = id {
13134        local_var_req_builder = match "multi" {
13135            "multi" => local_var_req_builder.query(
13136                &local_var_str
13137                    .into_iter()
13138                    .map(|p| ("id".to_owned(), p.to_string()))
13139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13140            ),
13141            _ => local_var_req_builder.query(&[(
13142                "id",
13143                &local_var_str
13144                    .into_iter()
13145                    .map(|p| p.to_string())
13146                    .collect::<Vec<String>>()
13147                    .join(",")
13148                    .to_string(),
13149            )]),
13150        };
13151    }
13152    if let Some(ref local_var_str) = id__empty {
13153        local_var_req_builder =
13154            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
13155    }
13156    if let Some(ref local_var_str) = id__gt {
13157        local_var_req_builder = match "multi" {
13158            "multi" => local_var_req_builder.query(
13159                &local_var_str
13160                    .into_iter()
13161                    .map(|p| ("id__gt".to_owned(), p.to_string()))
13162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13163            ),
13164            _ => local_var_req_builder.query(&[(
13165                "id__gt",
13166                &local_var_str
13167                    .into_iter()
13168                    .map(|p| p.to_string())
13169                    .collect::<Vec<String>>()
13170                    .join(",")
13171                    .to_string(),
13172            )]),
13173        };
13174    }
13175    if let Some(ref local_var_str) = id__gte {
13176        local_var_req_builder = match "multi" {
13177            "multi" => local_var_req_builder.query(
13178                &local_var_str
13179                    .into_iter()
13180                    .map(|p| ("id__gte".to_owned(), p.to_string()))
13181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13182            ),
13183            _ => local_var_req_builder.query(&[(
13184                "id__gte",
13185                &local_var_str
13186                    .into_iter()
13187                    .map(|p| p.to_string())
13188                    .collect::<Vec<String>>()
13189                    .join(",")
13190                    .to_string(),
13191            )]),
13192        };
13193    }
13194    if let Some(ref local_var_str) = id__lt {
13195        local_var_req_builder = match "multi" {
13196            "multi" => local_var_req_builder.query(
13197                &local_var_str
13198                    .into_iter()
13199                    .map(|p| ("id__lt".to_owned(), p.to_string()))
13200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13201            ),
13202            _ => local_var_req_builder.query(&[(
13203                "id__lt",
13204                &local_var_str
13205                    .into_iter()
13206                    .map(|p| p.to_string())
13207                    .collect::<Vec<String>>()
13208                    .join(",")
13209                    .to_string(),
13210            )]),
13211        };
13212    }
13213    if let Some(ref local_var_str) = id__lte {
13214        local_var_req_builder = match "multi" {
13215            "multi" => local_var_req_builder.query(
13216                &local_var_str
13217                    .into_iter()
13218                    .map(|p| ("id__lte".to_owned(), p.to_string()))
13219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13220            ),
13221            _ => local_var_req_builder.query(&[(
13222                "id__lte",
13223                &local_var_str
13224                    .into_iter()
13225                    .map(|p| p.to_string())
13226                    .collect::<Vec<String>>()
13227                    .join(",")
13228                    .to_string(),
13229            )]),
13230        };
13231    }
13232    if let Some(ref local_var_str) = id__n {
13233        local_var_req_builder = match "multi" {
13234            "multi" => local_var_req_builder.query(
13235                &local_var_str
13236                    .into_iter()
13237                    .map(|p| ("id__n".to_owned(), p.to_string()))
13238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13239            ),
13240            _ => local_var_req_builder.query(&[(
13241                "id__n",
13242                &local_var_str
13243                    .into_iter()
13244                    .map(|p| p.to_string())
13245                    .collect::<Vec<String>>()
13246                    .join(",")
13247                    .to_string(),
13248            )]),
13249        };
13250    }
13251    if let Some(ref local_var_str) = interface_count {
13252        local_var_req_builder = match "multi" {
13253            "multi" => local_var_req_builder.query(
13254                &local_var_str
13255                    .into_iter()
13256                    .map(|p| ("interface_count".to_owned(), p.to_string()))
13257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13258            ),
13259            _ => local_var_req_builder.query(&[(
13260                "interface_count",
13261                &local_var_str
13262                    .into_iter()
13263                    .map(|p| p.to_string())
13264                    .collect::<Vec<String>>()
13265                    .join(",")
13266                    .to_string(),
13267            )]),
13268        };
13269    }
13270    if let Some(ref local_var_str) = interface_count__empty {
13271        local_var_req_builder =
13272            local_var_req_builder.query(&[("interface_count__empty", &local_var_str.to_string())]);
13273    }
13274    if let Some(ref local_var_str) = interface_count__gt {
13275        local_var_req_builder = match "multi" {
13276            "multi" => local_var_req_builder.query(
13277                &local_var_str
13278                    .into_iter()
13279                    .map(|p| ("interface_count__gt".to_owned(), p.to_string()))
13280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13281            ),
13282            _ => local_var_req_builder.query(&[(
13283                "interface_count__gt",
13284                &local_var_str
13285                    .into_iter()
13286                    .map(|p| p.to_string())
13287                    .collect::<Vec<String>>()
13288                    .join(",")
13289                    .to_string(),
13290            )]),
13291        };
13292    }
13293    if let Some(ref local_var_str) = interface_count__gte {
13294        local_var_req_builder = match "multi" {
13295            "multi" => local_var_req_builder.query(
13296                &local_var_str
13297                    .into_iter()
13298                    .map(|p| ("interface_count__gte".to_owned(), p.to_string()))
13299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13300            ),
13301            _ => local_var_req_builder.query(&[(
13302                "interface_count__gte",
13303                &local_var_str
13304                    .into_iter()
13305                    .map(|p| p.to_string())
13306                    .collect::<Vec<String>>()
13307                    .join(",")
13308                    .to_string(),
13309            )]),
13310        };
13311    }
13312    if let Some(ref local_var_str) = interface_count__lt {
13313        local_var_req_builder = match "multi" {
13314            "multi" => local_var_req_builder.query(
13315                &local_var_str
13316                    .into_iter()
13317                    .map(|p| ("interface_count__lt".to_owned(), p.to_string()))
13318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13319            ),
13320            _ => local_var_req_builder.query(&[(
13321                "interface_count__lt",
13322                &local_var_str
13323                    .into_iter()
13324                    .map(|p| p.to_string())
13325                    .collect::<Vec<String>>()
13326                    .join(",")
13327                    .to_string(),
13328            )]),
13329        };
13330    }
13331    if let Some(ref local_var_str) = interface_count__lte {
13332        local_var_req_builder = match "multi" {
13333            "multi" => local_var_req_builder.query(
13334                &local_var_str
13335                    .into_iter()
13336                    .map(|p| ("interface_count__lte".to_owned(), p.to_string()))
13337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13338            ),
13339            _ => local_var_req_builder.query(&[(
13340                "interface_count__lte",
13341                &local_var_str
13342                    .into_iter()
13343                    .map(|p| p.to_string())
13344                    .collect::<Vec<String>>()
13345                    .join(",")
13346                    .to_string(),
13347            )]),
13348        };
13349    }
13350    if let Some(ref local_var_str) = interface_count__n {
13351        local_var_req_builder = match "multi" {
13352            "multi" => local_var_req_builder.query(
13353                &local_var_str
13354                    .into_iter()
13355                    .map(|p| ("interface_count__n".to_owned(), p.to_string()))
13356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13357            ),
13358            _ => local_var_req_builder.query(&[(
13359                "interface_count__n",
13360                &local_var_str
13361                    .into_iter()
13362                    .map(|p| p.to_string())
13363                    .collect::<Vec<String>>()
13364                    .join(",")
13365                    .to_string(),
13366            )]),
13367        };
13368    }
13369    if let Some(ref local_var_str) = last_updated {
13370        local_var_req_builder = match "multi" {
13371            "multi" => local_var_req_builder.query(
13372                &local_var_str
13373                    .into_iter()
13374                    .map(|p| ("last_updated".to_owned(), p.to_string()))
13375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13376            ),
13377            _ => local_var_req_builder.query(&[(
13378                "last_updated",
13379                &local_var_str
13380                    .into_iter()
13381                    .map(|p| p.to_string())
13382                    .collect::<Vec<String>>()
13383                    .join(",")
13384                    .to_string(),
13385            )]),
13386        };
13387    }
13388    if let Some(ref local_var_str) = last_updated__empty {
13389        local_var_req_builder = match "multi" {
13390            "multi" => local_var_req_builder.query(
13391                &local_var_str
13392                    .into_iter()
13393                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
13394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13395            ),
13396            _ => local_var_req_builder.query(&[(
13397                "last_updated__empty",
13398                &local_var_str
13399                    .into_iter()
13400                    .map(|p| p.to_string())
13401                    .collect::<Vec<String>>()
13402                    .join(",")
13403                    .to_string(),
13404            )]),
13405        };
13406    }
13407    if let Some(ref local_var_str) = last_updated__gt {
13408        local_var_req_builder = match "multi" {
13409            "multi" => local_var_req_builder.query(
13410                &local_var_str
13411                    .into_iter()
13412                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
13413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13414            ),
13415            _ => local_var_req_builder.query(&[(
13416                "last_updated__gt",
13417                &local_var_str
13418                    .into_iter()
13419                    .map(|p| p.to_string())
13420                    .collect::<Vec<String>>()
13421                    .join(",")
13422                    .to_string(),
13423            )]),
13424        };
13425    }
13426    if let Some(ref local_var_str) = last_updated__gte {
13427        local_var_req_builder = match "multi" {
13428            "multi" => local_var_req_builder.query(
13429                &local_var_str
13430                    .into_iter()
13431                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
13432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13433            ),
13434            _ => local_var_req_builder.query(&[(
13435                "last_updated__gte",
13436                &local_var_str
13437                    .into_iter()
13438                    .map(|p| p.to_string())
13439                    .collect::<Vec<String>>()
13440                    .join(",")
13441                    .to_string(),
13442            )]),
13443        };
13444    }
13445    if let Some(ref local_var_str) = last_updated__lt {
13446        local_var_req_builder = match "multi" {
13447            "multi" => local_var_req_builder.query(
13448                &local_var_str
13449                    .into_iter()
13450                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
13451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13452            ),
13453            _ => local_var_req_builder.query(&[(
13454                "last_updated__lt",
13455                &local_var_str
13456                    .into_iter()
13457                    .map(|p| p.to_string())
13458                    .collect::<Vec<String>>()
13459                    .join(",")
13460                    .to_string(),
13461            )]),
13462        };
13463    }
13464    if let Some(ref local_var_str) = last_updated__lte {
13465        local_var_req_builder = match "multi" {
13466            "multi" => local_var_req_builder.query(
13467                &local_var_str
13468                    .into_iter()
13469                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
13470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13471            ),
13472            _ => local_var_req_builder.query(&[(
13473                "last_updated__lte",
13474                &local_var_str
13475                    .into_iter()
13476                    .map(|p| p.to_string())
13477                    .collect::<Vec<String>>()
13478                    .join(",")
13479                    .to_string(),
13480            )]),
13481        };
13482    }
13483    if let Some(ref local_var_str) = last_updated__n {
13484        local_var_req_builder = match "multi" {
13485            "multi" => local_var_req_builder.query(
13486                &local_var_str
13487                    .into_iter()
13488                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
13489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13490            ),
13491            _ => local_var_req_builder.query(&[(
13492                "last_updated__n",
13493                &local_var_str
13494                    .into_iter()
13495                    .map(|p| p.to_string())
13496                    .collect::<Vec<String>>()
13497                    .join(",")
13498                    .to_string(),
13499            )]),
13500        };
13501    }
13502    if let Some(ref local_var_str) = limit {
13503        local_var_req_builder =
13504            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13505    }
13506    if let Some(ref local_var_str) = local_context_data {
13507        local_var_req_builder =
13508            local_var_req_builder.query(&[("local_context_data", &local_var_str.to_string())]);
13509    }
13510    if let Some(ref local_var_str) = mac_address {
13511        local_var_req_builder = match "multi" {
13512            "multi" => local_var_req_builder.query(
13513                &local_var_str
13514                    .into_iter()
13515                    .map(|p| ("mac_address".to_owned(), p.to_string()))
13516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13517            ),
13518            _ => local_var_req_builder.query(&[(
13519                "mac_address",
13520                &local_var_str
13521                    .into_iter()
13522                    .map(|p| p.to_string())
13523                    .collect::<Vec<String>>()
13524                    .join(",")
13525                    .to_string(),
13526            )]),
13527        };
13528    }
13529    if let Some(ref local_var_str) = mac_address__ic {
13530        local_var_req_builder = match "multi" {
13531            "multi" => local_var_req_builder.query(
13532                &local_var_str
13533                    .into_iter()
13534                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
13535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13536            ),
13537            _ => local_var_req_builder.query(&[(
13538                "mac_address__ic",
13539                &local_var_str
13540                    .into_iter()
13541                    .map(|p| p.to_string())
13542                    .collect::<Vec<String>>()
13543                    .join(",")
13544                    .to_string(),
13545            )]),
13546        };
13547    }
13548    if let Some(ref local_var_str) = mac_address__ie {
13549        local_var_req_builder = match "multi" {
13550            "multi" => local_var_req_builder.query(
13551                &local_var_str
13552                    .into_iter()
13553                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
13554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13555            ),
13556            _ => local_var_req_builder.query(&[(
13557                "mac_address__ie",
13558                &local_var_str
13559                    .into_iter()
13560                    .map(|p| p.to_string())
13561                    .collect::<Vec<String>>()
13562                    .join(",")
13563                    .to_string(),
13564            )]),
13565        };
13566    }
13567    if let Some(ref local_var_str) = mac_address__iew {
13568        local_var_req_builder = match "multi" {
13569            "multi" => local_var_req_builder.query(
13570                &local_var_str
13571                    .into_iter()
13572                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
13573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13574            ),
13575            _ => local_var_req_builder.query(&[(
13576                "mac_address__iew",
13577                &local_var_str
13578                    .into_iter()
13579                    .map(|p| p.to_string())
13580                    .collect::<Vec<String>>()
13581                    .join(",")
13582                    .to_string(),
13583            )]),
13584        };
13585    }
13586    if let Some(ref local_var_str) = mac_address__iregex {
13587        local_var_req_builder = match "multi" {
13588            "multi" => local_var_req_builder.query(
13589                &local_var_str
13590                    .into_iter()
13591                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
13592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13593            ),
13594            _ => local_var_req_builder.query(&[(
13595                "mac_address__iregex",
13596                &local_var_str
13597                    .into_iter()
13598                    .map(|p| p.to_string())
13599                    .collect::<Vec<String>>()
13600                    .join(",")
13601                    .to_string(),
13602            )]),
13603        };
13604    }
13605    if let Some(ref local_var_str) = mac_address__isw {
13606        local_var_req_builder = match "multi" {
13607            "multi" => local_var_req_builder.query(
13608                &local_var_str
13609                    .into_iter()
13610                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
13611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13612            ),
13613            _ => local_var_req_builder.query(&[(
13614                "mac_address__isw",
13615                &local_var_str
13616                    .into_iter()
13617                    .map(|p| p.to_string())
13618                    .collect::<Vec<String>>()
13619                    .join(",")
13620                    .to_string(),
13621            )]),
13622        };
13623    }
13624    if let Some(ref local_var_str) = mac_address__n {
13625        local_var_req_builder = match "multi" {
13626            "multi" => local_var_req_builder.query(
13627                &local_var_str
13628                    .into_iter()
13629                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
13630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13631            ),
13632            _ => local_var_req_builder.query(&[(
13633                "mac_address__n",
13634                &local_var_str
13635                    .into_iter()
13636                    .map(|p| p.to_string())
13637                    .collect::<Vec<String>>()
13638                    .join(",")
13639                    .to_string(),
13640            )]),
13641        };
13642    }
13643    if let Some(ref local_var_str) = mac_address__nic {
13644        local_var_req_builder = match "multi" {
13645            "multi" => local_var_req_builder.query(
13646                &local_var_str
13647                    .into_iter()
13648                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
13649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13650            ),
13651            _ => local_var_req_builder.query(&[(
13652                "mac_address__nic",
13653                &local_var_str
13654                    .into_iter()
13655                    .map(|p| p.to_string())
13656                    .collect::<Vec<String>>()
13657                    .join(",")
13658                    .to_string(),
13659            )]),
13660        };
13661    }
13662    if let Some(ref local_var_str) = mac_address__nie {
13663        local_var_req_builder = match "multi" {
13664            "multi" => local_var_req_builder.query(
13665                &local_var_str
13666                    .into_iter()
13667                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
13668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13669            ),
13670            _ => local_var_req_builder.query(&[(
13671                "mac_address__nie",
13672                &local_var_str
13673                    .into_iter()
13674                    .map(|p| p.to_string())
13675                    .collect::<Vec<String>>()
13676                    .join(",")
13677                    .to_string(),
13678            )]),
13679        };
13680    }
13681    if let Some(ref local_var_str) = mac_address__niew {
13682        local_var_req_builder = match "multi" {
13683            "multi" => local_var_req_builder.query(
13684                &local_var_str
13685                    .into_iter()
13686                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
13687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13688            ),
13689            _ => local_var_req_builder.query(&[(
13690                "mac_address__niew",
13691                &local_var_str
13692                    .into_iter()
13693                    .map(|p| p.to_string())
13694                    .collect::<Vec<String>>()
13695                    .join(",")
13696                    .to_string(),
13697            )]),
13698        };
13699    }
13700    if let Some(ref local_var_str) = mac_address__nisw {
13701        local_var_req_builder = match "multi" {
13702            "multi" => local_var_req_builder.query(
13703                &local_var_str
13704                    .into_iter()
13705                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
13706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13707            ),
13708            _ => local_var_req_builder.query(&[(
13709                "mac_address__nisw",
13710                &local_var_str
13711                    .into_iter()
13712                    .map(|p| p.to_string())
13713                    .collect::<Vec<String>>()
13714                    .join(",")
13715                    .to_string(),
13716            )]),
13717        };
13718    }
13719    if let Some(ref local_var_str) = mac_address__regex {
13720        local_var_req_builder = match "multi" {
13721            "multi" => local_var_req_builder.query(
13722                &local_var_str
13723                    .into_iter()
13724                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
13725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13726            ),
13727            _ => local_var_req_builder.query(&[(
13728                "mac_address__regex",
13729                &local_var_str
13730                    .into_iter()
13731                    .map(|p| p.to_string())
13732                    .collect::<Vec<String>>()
13733                    .join(",")
13734                    .to_string(),
13735            )]),
13736        };
13737    }
13738    if let Some(ref local_var_str) = memory {
13739        local_var_req_builder = match "multi" {
13740            "multi" => local_var_req_builder.query(
13741                &local_var_str
13742                    .into_iter()
13743                    .map(|p| ("memory".to_owned(), p.to_string()))
13744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13745            ),
13746            _ => local_var_req_builder.query(&[(
13747                "memory",
13748                &local_var_str
13749                    .into_iter()
13750                    .map(|p| p.to_string())
13751                    .collect::<Vec<String>>()
13752                    .join(",")
13753                    .to_string(),
13754            )]),
13755        };
13756    }
13757    if let Some(ref local_var_str) = memory__empty {
13758        local_var_req_builder =
13759            local_var_req_builder.query(&[("memory__empty", &local_var_str.to_string())]);
13760    }
13761    if let Some(ref local_var_str) = memory__gt {
13762        local_var_req_builder = match "multi" {
13763            "multi" => local_var_req_builder.query(
13764                &local_var_str
13765                    .into_iter()
13766                    .map(|p| ("memory__gt".to_owned(), p.to_string()))
13767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13768            ),
13769            _ => local_var_req_builder.query(&[(
13770                "memory__gt",
13771                &local_var_str
13772                    .into_iter()
13773                    .map(|p| p.to_string())
13774                    .collect::<Vec<String>>()
13775                    .join(",")
13776                    .to_string(),
13777            )]),
13778        };
13779    }
13780    if let Some(ref local_var_str) = memory__gte {
13781        local_var_req_builder = match "multi" {
13782            "multi" => local_var_req_builder.query(
13783                &local_var_str
13784                    .into_iter()
13785                    .map(|p| ("memory__gte".to_owned(), p.to_string()))
13786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13787            ),
13788            _ => local_var_req_builder.query(&[(
13789                "memory__gte",
13790                &local_var_str
13791                    .into_iter()
13792                    .map(|p| p.to_string())
13793                    .collect::<Vec<String>>()
13794                    .join(",")
13795                    .to_string(),
13796            )]),
13797        };
13798    }
13799    if let Some(ref local_var_str) = memory__lt {
13800        local_var_req_builder = match "multi" {
13801            "multi" => local_var_req_builder.query(
13802                &local_var_str
13803                    .into_iter()
13804                    .map(|p| ("memory__lt".to_owned(), p.to_string()))
13805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13806            ),
13807            _ => local_var_req_builder.query(&[(
13808                "memory__lt",
13809                &local_var_str
13810                    .into_iter()
13811                    .map(|p| p.to_string())
13812                    .collect::<Vec<String>>()
13813                    .join(",")
13814                    .to_string(),
13815            )]),
13816        };
13817    }
13818    if let Some(ref local_var_str) = memory__lte {
13819        local_var_req_builder = match "multi" {
13820            "multi" => local_var_req_builder.query(
13821                &local_var_str
13822                    .into_iter()
13823                    .map(|p| ("memory__lte".to_owned(), p.to_string()))
13824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13825            ),
13826            _ => local_var_req_builder.query(&[(
13827                "memory__lte",
13828                &local_var_str
13829                    .into_iter()
13830                    .map(|p| p.to_string())
13831                    .collect::<Vec<String>>()
13832                    .join(",")
13833                    .to_string(),
13834            )]),
13835        };
13836    }
13837    if let Some(ref local_var_str) = memory__n {
13838        local_var_req_builder = match "multi" {
13839            "multi" => local_var_req_builder.query(
13840                &local_var_str
13841                    .into_iter()
13842                    .map(|p| ("memory__n".to_owned(), p.to_string()))
13843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13844            ),
13845            _ => local_var_req_builder.query(&[(
13846                "memory__n",
13847                &local_var_str
13848                    .into_iter()
13849                    .map(|p| p.to_string())
13850                    .collect::<Vec<String>>()
13851                    .join(",")
13852                    .to_string(),
13853            )]),
13854        };
13855    }
13856    if let Some(ref local_var_str) = modified_by_request {
13857        local_var_req_builder =
13858            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
13859    }
13860    if let Some(ref local_var_str) = name {
13861        local_var_req_builder = match "multi" {
13862            "multi" => local_var_req_builder.query(
13863                &local_var_str
13864                    .into_iter()
13865                    .map(|p| ("name".to_owned(), p.to_string()))
13866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13867            ),
13868            _ => local_var_req_builder.query(&[(
13869                "name",
13870                &local_var_str
13871                    .into_iter()
13872                    .map(|p| p.to_string())
13873                    .collect::<Vec<String>>()
13874                    .join(",")
13875                    .to_string(),
13876            )]),
13877        };
13878    }
13879    if let Some(ref local_var_str) = name__empty {
13880        local_var_req_builder =
13881            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
13882    }
13883    if let Some(ref local_var_str) = name__ic {
13884        local_var_req_builder = match "multi" {
13885            "multi" => local_var_req_builder.query(
13886                &local_var_str
13887                    .into_iter()
13888                    .map(|p| ("name__ic".to_owned(), p.to_string()))
13889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13890            ),
13891            _ => local_var_req_builder.query(&[(
13892                "name__ic",
13893                &local_var_str
13894                    .into_iter()
13895                    .map(|p| p.to_string())
13896                    .collect::<Vec<String>>()
13897                    .join(",")
13898                    .to_string(),
13899            )]),
13900        };
13901    }
13902    if let Some(ref local_var_str) = name__ie {
13903        local_var_req_builder = match "multi" {
13904            "multi" => local_var_req_builder.query(
13905                &local_var_str
13906                    .into_iter()
13907                    .map(|p| ("name__ie".to_owned(), p.to_string()))
13908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13909            ),
13910            _ => local_var_req_builder.query(&[(
13911                "name__ie",
13912                &local_var_str
13913                    .into_iter()
13914                    .map(|p| p.to_string())
13915                    .collect::<Vec<String>>()
13916                    .join(",")
13917                    .to_string(),
13918            )]),
13919        };
13920    }
13921    if let Some(ref local_var_str) = name__iew {
13922        local_var_req_builder = match "multi" {
13923            "multi" => local_var_req_builder.query(
13924                &local_var_str
13925                    .into_iter()
13926                    .map(|p| ("name__iew".to_owned(), p.to_string()))
13927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13928            ),
13929            _ => local_var_req_builder.query(&[(
13930                "name__iew",
13931                &local_var_str
13932                    .into_iter()
13933                    .map(|p| p.to_string())
13934                    .collect::<Vec<String>>()
13935                    .join(",")
13936                    .to_string(),
13937            )]),
13938        };
13939    }
13940    if let Some(ref local_var_str) = name__iregex {
13941        local_var_req_builder = match "multi" {
13942            "multi" => local_var_req_builder.query(
13943                &local_var_str
13944                    .into_iter()
13945                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
13946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13947            ),
13948            _ => local_var_req_builder.query(&[(
13949                "name__iregex",
13950                &local_var_str
13951                    .into_iter()
13952                    .map(|p| p.to_string())
13953                    .collect::<Vec<String>>()
13954                    .join(",")
13955                    .to_string(),
13956            )]),
13957        };
13958    }
13959    if let Some(ref local_var_str) = name__isw {
13960        local_var_req_builder = match "multi" {
13961            "multi" => local_var_req_builder.query(
13962                &local_var_str
13963                    .into_iter()
13964                    .map(|p| ("name__isw".to_owned(), p.to_string()))
13965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13966            ),
13967            _ => local_var_req_builder.query(&[(
13968                "name__isw",
13969                &local_var_str
13970                    .into_iter()
13971                    .map(|p| p.to_string())
13972                    .collect::<Vec<String>>()
13973                    .join(",")
13974                    .to_string(),
13975            )]),
13976        };
13977    }
13978    if let Some(ref local_var_str) = name__n {
13979        local_var_req_builder = match "multi" {
13980            "multi" => local_var_req_builder.query(
13981                &local_var_str
13982                    .into_iter()
13983                    .map(|p| ("name__n".to_owned(), p.to_string()))
13984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13985            ),
13986            _ => local_var_req_builder.query(&[(
13987                "name__n",
13988                &local_var_str
13989                    .into_iter()
13990                    .map(|p| p.to_string())
13991                    .collect::<Vec<String>>()
13992                    .join(",")
13993                    .to_string(),
13994            )]),
13995        };
13996    }
13997    if let Some(ref local_var_str) = name__nic {
13998        local_var_req_builder = match "multi" {
13999            "multi" => local_var_req_builder.query(
14000                &local_var_str
14001                    .into_iter()
14002                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14004            ),
14005            _ => local_var_req_builder.query(&[(
14006                "name__nic",
14007                &local_var_str
14008                    .into_iter()
14009                    .map(|p| p.to_string())
14010                    .collect::<Vec<String>>()
14011                    .join(",")
14012                    .to_string(),
14013            )]),
14014        };
14015    }
14016    if let Some(ref local_var_str) = name__nie {
14017        local_var_req_builder = match "multi" {
14018            "multi" => local_var_req_builder.query(
14019                &local_var_str
14020                    .into_iter()
14021                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14023            ),
14024            _ => local_var_req_builder.query(&[(
14025                "name__nie",
14026                &local_var_str
14027                    .into_iter()
14028                    .map(|p| p.to_string())
14029                    .collect::<Vec<String>>()
14030                    .join(",")
14031                    .to_string(),
14032            )]),
14033        };
14034    }
14035    if let Some(ref local_var_str) = name__niew {
14036        local_var_req_builder = match "multi" {
14037            "multi" => local_var_req_builder.query(
14038                &local_var_str
14039                    .into_iter()
14040                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14042            ),
14043            _ => local_var_req_builder.query(&[(
14044                "name__niew",
14045                &local_var_str
14046                    .into_iter()
14047                    .map(|p| p.to_string())
14048                    .collect::<Vec<String>>()
14049                    .join(",")
14050                    .to_string(),
14051            )]),
14052        };
14053    }
14054    if let Some(ref local_var_str) = name__nisw {
14055        local_var_req_builder = match "multi" {
14056            "multi" => local_var_req_builder.query(
14057                &local_var_str
14058                    .into_iter()
14059                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14061            ),
14062            _ => local_var_req_builder.query(&[(
14063                "name__nisw",
14064                &local_var_str
14065                    .into_iter()
14066                    .map(|p| p.to_string())
14067                    .collect::<Vec<String>>()
14068                    .join(",")
14069                    .to_string(),
14070            )]),
14071        };
14072    }
14073    if let Some(ref local_var_str) = name__regex {
14074        local_var_req_builder = match "multi" {
14075            "multi" => local_var_req_builder.query(
14076                &local_var_str
14077                    .into_iter()
14078                    .map(|p| ("name__regex".to_owned(), p.to_string()))
14079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14080            ),
14081            _ => local_var_req_builder.query(&[(
14082                "name__regex",
14083                &local_var_str
14084                    .into_iter()
14085                    .map(|p| p.to_string())
14086                    .collect::<Vec<String>>()
14087                    .join(",")
14088                    .to_string(),
14089            )]),
14090        };
14091    }
14092    if let Some(ref local_var_str) = offset {
14093        local_var_req_builder =
14094            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14095    }
14096    if let Some(ref local_var_str) = ordering {
14097        local_var_req_builder =
14098            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
14099    }
14100    if let Some(ref local_var_str) = owner {
14101        local_var_req_builder = match "multi" {
14102            "multi" => local_var_req_builder.query(
14103                &local_var_str
14104                    .into_iter()
14105                    .map(|p| ("owner".to_owned(), p.to_string()))
14106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14107            ),
14108            _ => local_var_req_builder.query(&[(
14109                "owner",
14110                &local_var_str
14111                    .into_iter()
14112                    .map(|p| p.to_string())
14113                    .collect::<Vec<String>>()
14114                    .join(",")
14115                    .to_string(),
14116            )]),
14117        };
14118    }
14119    if let Some(ref local_var_str) = owner__n {
14120        local_var_req_builder = match "multi" {
14121            "multi" => local_var_req_builder.query(
14122                &local_var_str
14123                    .into_iter()
14124                    .map(|p| ("owner__n".to_owned(), p.to_string()))
14125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14126            ),
14127            _ => local_var_req_builder.query(&[(
14128                "owner__n",
14129                &local_var_str
14130                    .into_iter()
14131                    .map(|p| p.to_string())
14132                    .collect::<Vec<String>>()
14133                    .join(",")
14134                    .to_string(),
14135            )]),
14136        };
14137    }
14138    if let Some(ref local_var_str) = owner_group {
14139        local_var_req_builder = match "multi" {
14140            "multi" => local_var_req_builder.query(
14141                &local_var_str
14142                    .into_iter()
14143                    .map(|p| ("owner_group".to_owned(), p.to_string()))
14144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14145            ),
14146            _ => local_var_req_builder.query(&[(
14147                "owner_group",
14148                &local_var_str
14149                    .into_iter()
14150                    .map(|p| p.to_string())
14151                    .collect::<Vec<String>>()
14152                    .join(",")
14153                    .to_string(),
14154            )]),
14155        };
14156    }
14157    if let Some(ref local_var_str) = owner_group__n {
14158        local_var_req_builder = match "multi" {
14159            "multi" => local_var_req_builder.query(
14160                &local_var_str
14161                    .into_iter()
14162                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
14163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14164            ),
14165            _ => local_var_req_builder.query(&[(
14166                "owner_group__n",
14167                &local_var_str
14168                    .into_iter()
14169                    .map(|p| p.to_string())
14170                    .collect::<Vec<String>>()
14171                    .join(",")
14172                    .to_string(),
14173            )]),
14174        };
14175    }
14176    if let Some(ref local_var_str) = owner_group_id {
14177        local_var_req_builder = match "multi" {
14178            "multi" => local_var_req_builder.query(
14179                &local_var_str
14180                    .into_iter()
14181                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
14182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14183            ),
14184            _ => local_var_req_builder.query(&[(
14185                "owner_group_id",
14186                &local_var_str
14187                    .into_iter()
14188                    .map(|p| p.to_string())
14189                    .collect::<Vec<String>>()
14190                    .join(",")
14191                    .to_string(),
14192            )]),
14193        };
14194    }
14195    if let Some(ref local_var_str) = owner_group_id__n {
14196        local_var_req_builder = match "multi" {
14197            "multi" => local_var_req_builder.query(
14198                &local_var_str
14199                    .into_iter()
14200                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
14201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14202            ),
14203            _ => local_var_req_builder.query(&[(
14204                "owner_group_id__n",
14205                &local_var_str
14206                    .into_iter()
14207                    .map(|p| p.to_string())
14208                    .collect::<Vec<String>>()
14209                    .join(",")
14210                    .to_string(),
14211            )]),
14212        };
14213    }
14214    if let Some(ref local_var_str) = owner_id {
14215        local_var_req_builder = match "multi" {
14216            "multi" => local_var_req_builder.query(
14217                &local_var_str
14218                    .into_iter()
14219                    .map(|p| ("owner_id".to_owned(), p.to_string()))
14220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14221            ),
14222            _ => local_var_req_builder.query(&[(
14223                "owner_id",
14224                &local_var_str
14225                    .into_iter()
14226                    .map(|p| p.to_string())
14227                    .collect::<Vec<String>>()
14228                    .join(",")
14229                    .to_string(),
14230            )]),
14231        };
14232    }
14233    if let Some(ref local_var_str) = owner_id__n {
14234        local_var_req_builder = match "multi" {
14235            "multi" => local_var_req_builder.query(
14236                &local_var_str
14237                    .into_iter()
14238                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
14239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14240            ),
14241            _ => local_var_req_builder.query(&[(
14242                "owner_id__n",
14243                &local_var_str
14244                    .into_iter()
14245                    .map(|p| p.to_string())
14246                    .collect::<Vec<String>>()
14247                    .join(",")
14248                    .to_string(),
14249            )]),
14250        };
14251    }
14252    if let Some(ref local_var_str) = platform {
14253        local_var_req_builder = match "multi" {
14254            "multi" => local_var_req_builder.query(
14255                &local_var_str
14256                    .into_iter()
14257                    .map(|p| ("platform".to_owned(), p.to_string()))
14258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14259            ),
14260            _ => local_var_req_builder.query(&[(
14261                "platform",
14262                &local_var_str
14263                    .into_iter()
14264                    .map(|p| p.to_string())
14265                    .collect::<Vec<String>>()
14266                    .join(",")
14267                    .to_string(),
14268            )]),
14269        };
14270    }
14271    if let Some(ref local_var_str) = platform__n {
14272        local_var_req_builder = match "multi" {
14273            "multi" => local_var_req_builder.query(
14274                &local_var_str
14275                    .into_iter()
14276                    .map(|p| ("platform__n".to_owned(), p.to_string()))
14277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14278            ),
14279            _ => local_var_req_builder.query(&[(
14280                "platform__n",
14281                &local_var_str
14282                    .into_iter()
14283                    .map(|p| p.to_string())
14284                    .collect::<Vec<String>>()
14285                    .join(",")
14286                    .to_string(),
14287            )]),
14288        };
14289    }
14290    if let Some(ref local_var_str) = platform_id {
14291        local_var_req_builder = match "multi" {
14292            "multi" => local_var_req_builder.query(
14293                &local_var_str
14294                    .into_iter()
14295                    .map(|p| ("platform_id".to_owned(), p.to_string()))
14296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14297            ),
14298            _ => local_var_req_builder.query(&[(
14299                "platform_id",
14300                &local_var_str
14301                    .into_iter()
14302                    .map(|p| p.to_string())
14303                    .collect::<Vec<String>>()
14304                    .join(",")
14305                    .to_string(),
14306            )]),
14307        };
14308    }
14309    if let Some(ref local_var_str) = platform_id__n {
14310        local_var_req_builder = match "multi" {
14311            "multi" => local_var_req_builder.query(
14312                &local_var_str
14313                    .into_iter()
14314                    .map(|p| ("platform_id__n".to_owned(), p.to_string()))
14315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14316            ),
14317            _ => local_var_req_builder.query(&[(
14318                "platform_id__n",
14319                &local_var_str
14320                    .into_iter()
14321                    .map(|p| p.to_string())
14322                    .collect::<Vec<String>>()
14323                    .join(",")
14324                    .to_string(),
14325            )]),
14326        };
14327    }
14328    if let Some(ref local_var_str) = primary_ip4 {
14329        local_var_req_builder = match "multi" {
14330            "multi" => local_var_req_builder.query(
14331                &local_var_str
14332                    .into_iter()
14333                    .map(|p| ("primary_ip4".to_owned(), p.to_string()))
14334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14335            ),
14336            _ => local_var_req_builder.query(&[(
14337                "primary_ip4",
14338                &local_var_str
14339                    .into_iter()
14340                    .map(|p| p.to_string())
14341                    .collect::<Vec<String>>()
14342                    .join(",")
14343                    .to_string(),
14344            )]),
14345        };
14346    }
14347    if let Some(ref local_var_str) = primary_ip4__n {
14348        local_var_req_builder = match "multi" {
14349            "multi" => local_var_req_builder.query(
14350                &local_var_str
14351                    .into_iter()
14352                    .map(|p| ("primary_ip4__n".to_owned(), p.to_string()))
14353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14354            ),
14355            _ => local_var_req_builder.query(&[(
14356                "primary_ip4__n",
14357                &local_var_str
14358                    .into_iter()
14359                    .map(|p| p.to_string())
14360                    .collect::<Vec<String>>()
14361                    .join(",")
14362                    .to_string(),
14363            )]),
14364        };
14365    }
14366    if let Some(ref local_var_str) = primary_ip4_id {
14367        local_var_req_builder = match "multi" {
14368            "multi" => local_var_req_builder.query(
14369                &local_var_str
14370                    .into_iter()
14371                    .map(|p| ("primary_ip4_id".to_owned(), p.to_string()))
14372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14373            ),
14374            _ => local_var_req_builder.query(&[(
14375                "primary_ip4_id",
14376                &local_var_str
14377                    .into_iter()
14378                    .map(|p| p.to_string())
14379                    .collect::<Vec<String>>()
14380                    .join(",")
14381                    .to_string(),
14382            )]),
14383        };
14384    }
14385    if let Some(ref local_var_str) = primary_ip4_id__n {
14386        local_var_req_builder = match "multi" {
14387            "multi" => local_var_req_builder.query(
14388                &local_var_str
14389                    .into_iter()
14390                    .map(|p| ("primary_ip4_id__n".to_owned(), p.to_string()))
14391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14392            ),
14393            _ => local_var_req_builder.query(&[(
14394                "primary_ip4_id__n",
14395                &local_var_str
14396                    .into_iter()
14397                    .map(|p| p.to_string())
14398                    .collect::<Vec<String>>()
14399                    .join(",")
14400                    .to_string(),
14401            )]),
14402        };
14403    }
14404    if let Some(ref local_var_str) = primary_ip6 {
14405        local_var_req_builder = match "multi" {
14406            "multi" => local_var_req_builder.query(
14407                &local_var_str
14408                    .into_iter()
14409                    .map(|p| ("primary_ip6".to_owned(), p.to_string()))
14410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14411            ),
14412            _ => local_var_req_builder.query(&[(
14413                "primary_ip6",
14414                &local_var_str
14415                    .into_iter()
14416                    .map(|p| p.to_string())
14417                    .collect::<Vec<String>>()
14418                    .join(",")
14419                    .to_string(),
14420            )]),
14421        };
14422    }
14423    if let Some(ref local_var_str) = primary_ip6__n {
14424        local_var_req_builder = match "multi" {
14425            "multi" => local_var_req_builder.query(
14426                &local_var_str
14427                    .into_iter()
14428                    .map(|p| ("primary_ip6__n".to_owned(), p.to_string()))
14429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14430            ),
14431            _ => local_var_req_builder.query(&[(
14432                "primary_ip6__n",
14433                &local_var_str
14434                    .into_iter()
14435                    .map(|p| p.to_string())
14436                    .collect::<Vec<String>>()
14437                    .join(",")
14438                    .to_string(),
14439            )]),
14440        };
14441    }
14442    if let Some(ref local_var_str) = primary_ip6_id {
14443        local_var_req_builder = match "multi" {
14444            "multi" => local_var_req_builder.query(
14445                &local_var_str
14446                    .into_iter()
14447                    .map(|p| ("primary_ip6_id".to_owned(), p.to_string()))
14448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14449            ),
14450            _ => local_var_req_builder.query(&[(
14451                "primary_ip6_id",
14452                &local_var_str
14453                    .into_iter()
14454                    .map(|p| p.to_string())
14455                    .collect::<Vec<String>>()
14456                    .join(",")
14457                    .to_string(),
14458            )]),
14459        };
14460    }
14461    if let Some(ref local_var_str) = primary_ip6_id__n {
14462        local_var_req_builder = match "multi" {
14463            "multi" => local_var_req_builder.query(
14464                &local_var_str
14465                    .into_iter()
14466                    .map(|p| ("primary_ip6_id__n".to_owned(), p.to_string()))
14467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14468            ),
14469            _ => local_var_req_builder.query(&[(
14470                "primary_ip6_id__n",
14471                &local_var_str
14472                    .into_iter()
14473                    .map(|p| p.to_string())
14474                    .collect::<Vec<String>>()
14475                    .join(",")
14476                    .to_string(),
14477            )]),
14478        };
14479    }
14480    if let Some(ref local_var_str) = q {
14481        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
14482    }
14483    if let Some(ref local_var_str) = region {
14484        local_var_req_builder = match "multi" {
14485            "multi" => local_var_req_builder.query(
14486                &local_var_str
14487                    .into_iter()
14488                    .map(|p| ("region".to_owned(), p.to_string()))
14489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14490            ),
14491            _ => local_var_req_builder.query(&[(
14492                "region",
14493                &local_var_str
14494                    .into_iter()
14495                    .map(|p| p.to_string())
14496                    .collect::<Vec<String>>()
14497                    .join(",")
14498                    .to_string(),
14499            )]),
14500        };
14501    }
14502    if let Some(ref local_var_str) = region__n {
14503        local_var_req_builder = match "multi" {
14504            "multi" => local_var_req_builder.query(
14505                &local_var_str
14506                    .into_iter()
14507                    .map(|p| ("region__n".to_owned(), p.to_string()))
14508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14509            ),
14510            _ => local_var_req_builder.query(&[(
14511                "region__n",
14512                &local_var_str
14513                    .into_iter()
14514                    .map(|p| p.to_string())
14515                    .collect::<Vec<String>>()
14516                    .join(",")
14517                    .to_string(),
14518            )]),
14519        };
14520    }
14521    if let Some(ref local_var_str) = region_id {
14522        local_var_req_builder = match "multi" {
14523            "multi" => local_var_req_builder.query(
14524                &local_var_str
14525                    .into_iter()
14526                    .map(|p| ("region_id".to_owned(), p.to_string()))
14527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14528            ),
14529            _ => local_var_req_builder.query(&[(
14530                "region_id",
14531                &local_var_str
14532                    .into_iter()
14533                    .map(|p| p.to_string())
14534                    .collect::<Vec<String>>()
14535                    .join(",")
14536                    .to_string(),
14537            )]),
14538        };
14539    }
14540    if let Some(ref local_var_str) = region_id__n {
14541        local_var_req_builder = match "multi" {
14542            "multi" => local_var_req_builder.query(
14543                &local_var_str
14544                    .into_iter()
14545                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
14546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14547            ),
14548            _ => local_var_req_builder.query(&[(
14549                "region_id__n",
14550                &local_var_str
14551                    .into_iter()
14552                    .map(|p| p.to_string())
14553                    .collect::<Vec<String>>()
14554                    .join(",")
14555                    .to_string(),
14556            )]),
14557        };
14558    }
14559    if let Some(ref local_var_str) = role {
14560        local_var_req_builder = match "multi" {
14561            "multi" => local_var_req_builder.query(
14562                &local_var_str
14563                    .into_iter()
14564                    .map(|p| ("role".to_owned(), p.to_string()))
14565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14566            ),
14567            _ => local_var_req_builder.query(&[(
14568                "role",
14569                &local_var_str
14570                    .into_iter()
14571                    .map(|p| p.to_string())
14572                    .collect::<Vec<String>>()
14573                    .join(",")
14574                    .to_string(),
14575            )]),
14576        };
14577    }
14578    if let Some(ref local_var_str) = role__n {
14579        local_var_req_builder = match "multi" {
14580            "multi" => local_var_req_builder.query(
14581                &local_var_str
14582                    .into_iter()
14583                    .map(|p| ("role__n".to_owned(), p.to_string()))
14584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14585            ),
14586            _ => local_var_req_builder.query(&[(
14587                "role__n",
14588                &local_var_str
14589                    .into_iter()
14590                    .map(|p| p.to_string())
14591                    .collect::<Vec<String>>()
14592                    .join(",")
14593                    .to_string(),
14594            )]),
14595        };
14596    }
14597    if let Some(ref local_var_str) = role_id {
14598        local_var_req_builder = match "multi" {
14599            "multi" => local_var_req_builder.query(
14600                &local_var_str
14601                    .into_iter()
14602                    .map(|p| ("role_id".to_owned(), p.to_string()))
14603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14604            ),
14605            _ => local_var_req_builder.query(&[(
14606                "role_id",
14607                &local_var_str
14608                    .into_iter()
14609                    .map(|p| p.to_string())
14610                    .collect::<Vec<String>>()
14611                    .join(",")
14612                    .to_string(),
14613            )]),
14614        };
14615    }
14616    if let Some(ref local_var_str) = role_id__n {
14617        local_var_req_builder = match "multi" {
14618            "multi" => local_var_req_builder.query(
14619                &local_var_str
14620                    .into_iter()
14621                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
14622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14623            ),
14624            _ => local_var_req_builder.query(&[(
14625                "role_id__n",
14626                &local_var_str
14627                    .into_iter()
14628                    .map(|p| p.to_string())
14629                    .collect::<Vec<String>>()
14630                    .join(",")
14631                    .to_string(),
14632            )]),
14633        };
14634    }
14635    if let Some(ref local_var_str) = serial {
14636        local_var_req_builder = match "multi" {
14637            "multi" => local_var_req_builder.query(
14638                &local_var_str
14639                    .into_iter()
14640                    .map(|p| ("serial".to_owned(), p.to_string()))
14641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14642            ),
14643            _ => local_var_req_builder.query(&[(
14644                "serial",
14645                &local_var_str
14646                    .into_iter()
14647                    .map(|p| p.to_string())
14648                    .collect::<Vec<String>>()
14649                    .join(",")
14650                    .to_string(),
14651            )]),
14652        };
14653    }
14654    if let Some(ref local_var_str) = serial__empty {
14655        local_var_req_builder =
14656            local_var_req_builder.query(&[("serial__empty", &local_var_str.to_string())]);
14657    }
14658    if let Some(ref local_var_str) = serial__ic {
14659        local_var_req_builder = match "multi" {
14660            "multi" => local_var_req_builder.query(
14661                &local_var_str
14662                    .into_iter()
14663                    .map(|p| ("serial__ic".to_owned(), p.to_string()))
14664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14665            ),
14666            _ => local_var_req_builder.query(&[(
14667                "serial__ic",
14668                &local_var_str
14669                    .into_iter()
14670                    .map(|p| p.to_string())
14671                    .collect::<Vec<String>>()
14672                    .join(",")
14673                    .to_string(),
14674            )]),
14675        };
14676    }
14677    if let Some(ref local_var_str) = serial__ie {
14678        local_var_req_builder = match "multi" {
14679            "multi" => local_var_req_builder.query(
14680                &local_var_str
14681                    .into_iter()
14682                    .map(|p| ("serial__ie".to_owned(), p.to_string()))
14683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14684            ),
14685            _ => local_var_req_builder.query(&[(
14686                "serial__ie",
14687                &local_var_str
14688                    .into_iter()
14689                    .map(|p| p.to_string())
14690                    .collect::<Vec<String>>()
14691                    .join(",")
14692                    .to_string(),
14693            )]),
14694        };
14695    }
14696    if let Some(ref local_var_str) = serial__iew {
14697        local_var_req_builder = match "multi" {
14698            "multi" => local_var_req_builder.query(
14699                &local_var_str
14700                    .into_iter()
14701                    .map(|p| ("serial__iew".to_owned(), p.to_string()))
14702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14703            ),
14704            _ => local_var_req_builder.query(&[(
14705                "serial__iew",
14706                &local_var_str
14707                    .into_iter()
14708                    .map(|p| p.to_string())
14709                    .collect::<Vec<String>>()
14710                    .join(",")
14711                    .to_string(),
14712            )]),
14713        };
14714    }
14715    if let Some(ref local_var_str) = serial__iregex {
14716        local_var_req_builder = match "multi" {
14717            "multi" => local_var_req_builder.query(
14718                &local_var_str
14719                    .into_iter()
14720                    .map(|p| ("serial__iregex".to_owned(), p.to_string()))
14721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14722            ),
14723            _ => local_var_req_builder.query(&[(
14724                "serial__iregex",
14725                &local_var_str
14726                    .into_iter()
14727                    .map(|p| p.to_string())
14728                    .collect::<Vec<String>>()
14729                    .join(",")
14730                    .to_string(),
14731            )]),
14732        };
14733    }
14734    if let Some(ref local_var_str) = serial__isw {
14735        local_var_req_builder = match "multi" {
14736            "multi" => local_var_req_builder.query(
14737                &local_var_str
14738                    .into_iter()
14739                    .map(|p| ("serial__isw".to_owned(), p.to_string()))
14740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14741            ),
14742            _ => local_var_req_builder.query(&[(
14743                "serial__isw",
14744                &local_var_str
14745                    .into_iter()
14746                    .map(|p| p.to_string())
14747                    .collect::<Vec<String>>()
14748                    .join(",")
14749                    .to_string(),
14750            )]),
14751        };
14752    }
14753    if let Some(ref local_var_str) = serial__n {
14754        local_var_req_builder = match "multi" {
14755            "multi" => local_var_req_builder.query(
14756                &local_var_str
14757                    .into_iter()
14758                    .map(|p| ("serial__n".to_owned(), p.to_string()))
14759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14760            ),
14761            _ => local_var_req_builder.query(&[(
14762                "serial__n",
14763                &local_var_str
14764                    .into_iter()
14765                    .map(|p| p.to_string())
14766                    .collect::<Vec<String>>()
14767                    .join(",")
14768                    .to_string(),
14769            )]),
14770        };
14771    }
14772    if let Some(ref local_var_str) = serial__nic {
14773        local_var_req_builder = match "multi" {
14774            "multi" => local_var_req_builder.query(
14775                &local_var_str
14776                    .into_iter()
14777                    .map(|p| ("serial__nic".to_owned(), p.to_string()))
14778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14779            ),
14780            _ => local_var_req_builder.query(&[(
14781                "serial__nic",
14782                &local_var_str
14783                    .into_iter()
14784                    .map(|p| p.to_string())
14785                    .collect::<Vec<String>>()
14786                    .join(",")
14787                    .to_string(),
14788            )]),
14789        };
14790    }
14791    if let Some(ref local_var_str) = serial__nie {
14792        local_var_req_builder = match "multi" {
14793            "multi" => local_var_req_builder.query(
14794                &local_var_str
14795                    .into_iter()
14796                    .map(|p| ("serial__nie".to_owned(), p.to_string()))
14797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14798            ),
14799            _ => local_var_req_builder.query(&[(
14800                "serial__nie",
14801                &local_var_str
14802                    .into_iter()
14803                    .map(|p| p.to_string())
14804                    .collect::<Vec<String>>()
14805                    .join(",")
14806                    .to_string(),
14807            )]),
14808        };
14809    }
14810    if let Some(ref local_var_str) = serial__niew {
14811        local_var_req_builder = match "multi" {
14812            "multi" => local_var_req_builder.query(
14813                &local_var_str
14814                    .into_iter()
14815                    .map(|p| ("serial__niew".to_owned(), p.to_string()))
14816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14817            ),
14818            _ => local_var_req_builder.query(&[(
14819                "serial__niew",
14820                &local_var_str
14821                    .into_iter()
14822                    .map(|p| p.to_string())
14823                    .collect::<Vec<String>>()
14824                    .join(",")
14825                    .to_string(),
14826            )]),
14827        };
14828    }
14829    if let Some(ref local_var_str) = serial__nisw {
14830        local_var_req_builder = match "multi" {
14831            "multi" => local_var_req_builder.query(
14832                &local_var_str
14833                    .into_iter()
14834                    .map(|p| ("serial__nisw".to_owned(), p.to_string()))
14835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14836            ),
14837            _ => local_var_req_builder.query(&[(
14838                "serial__nisw",
14839                &local_var_str
14840                    .into_iter()
14841                    .map(|p| p.to_string())
14842                    .collect::<Vec<String>>()
14843                    .join(",")
14844                    .to_string(),
14845            )]),
14846        };
14847    }
14848    if let Some(ref local_var_str) = serial__regex {
14849        local_var_req_builder = match "multi" {
14850            "multi" => local_var_req_builder.query(
14851                &local_var_str
14852                    .into_iter()
14853                    .map(|p| ("serial__regex".to_owned(), p.to_string()))
14854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14855            ),
14856            _ => local_var_req_builder.query(&[(
14857                "serial__regex",
14858                &local_var_str
14859                    .into_iter()
14860                    .map(|p| p.to_string())
14861                    .collect::<Vec<String>>()
14862                    .join(",")
14863                    .to_string(),
14864            )]),
14865        };
14866    }
14867    if let Some(ref local_var_str) = site {
14868        local_var_req_builder = match "multi" {
14869            "multi" => local_var_req_builder.query(
14870                &local_var_str
14871                    .into_iter()
14872                    .map(|p| ("site".to_owned(), p.to_string()))
14873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14874            ),
14875            _ => local_var_req_builder.query(&[(
14876                "site",
14877                &local_var_str
14878                    .into_iter()
14879                    .map(|p| p.to_string())
14880                    .collect::<Vec<String>>()
14881                    .join(",")
14882                    .to_string(),
14883            )]),
14884        };
14885    }
14886    if let Some(ref local_var_str) = site__n {
14887        local_var_req_builder = match "multi" {
14888            "multi" => local_var_req_builder.query(
14889                &local_var_str
14890                    .into_iter()
14891                    .map(|p| ("site__n".to_owned(), p.to_string()))
14892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14893            ),
14894            _ => local_var_req_builder.query(&[(
14895                "site__n",
14896                &local_var_str
14897                    .into_iter()
14898                    .map(|p| p.to_string())
14899                    .collect::<Vec<String>>()
14900                    .join(",")
14901                    .to_string(),
14902            )]),
14903        };
14904    }
14905    if let Some(ref local_var_str) = site_group {
14906        local_var_req_builder = match "multi" {
14907            "multi" => local_var_req_builder.query(
14908                &local_var_str
14909                    .into_iter()
14910                    .map(|p| ("site_group".to_owned(), p.to_string()))
14911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14912            ),
14913            _ => local_var_req_builder.query(&[(
14914                "site_group",
14915                &local_var_str
14916                    .into_iter()
14917                    .map(|p| p.to_string())
14918                    .collect::<Vec<String>>()
14919                    .join(",")
14920                    .to_string(),
14921            )]),
14922        };
14923    }
14924    if let Some(ref local_var_str) = site_group__n {
14925        local_var_req_builder = match "multi" {
14926            "multi" => local_var_req_builder.query(
14927                &local_var_str
14928                    .into_iter()
14929                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
14930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14931            ),
14932            _ => local_var_req_builder.query(&[(
14933                "site_group__n",
14934                &local_var_str
14935                    .into_iter()
14936                    .map(|p| p.to_string())
14937                    .collect::<Vec<String>>()
14938                    .join(",")
14939                    .to_string(),
14940            )]),
14941        };
14942    }
14943    if let Some(ref local_var_str) = site_group_id {
14944        local_var_req_builder = match "multi" {
14945            "multi" => local_var_req_builder.query(
14946                &local_var_str
14947                    .into_iter()
14948                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
14949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14950            ),
14951            _ => local_var_req_builder.query(&[(
14952                "site_group_id",
14953                &local_var_str
14954                    .into_iter()
14955                    .map(|p| p.to_string())
14956                    .collect::<Vec<String>>()
14957                    .join(",")
14958                    .to_string(),
14959            )]),
14960        };
14961    }
14962    if let Some(ref local_var_str) = site_group_id__n {
14963        local_var_req_builder = match "multi" {
14964            "multi" => local_var_req_builder.query(
14965                &local_var_str
14966                    .into_iter()
14967                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
14968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14969            ),
14970            _ => local_var_req_builder.query(&[(
14971                "site_group_id__n",
14972                &local_var_str
14973                    .into_iter()
14974                    .map(|p| p.to_string())
14975                    .collect::<Vec<String>>()
14976                    .join(",")
14977                    .to_string(),
14978            )]),
14979        };
14980    }
14981    if let Some(ref local_var_str) = site_id {
14982        local_var_req_builder = match "multi" {
14983            "multi" => local_var_req_builder.query(
14984                &local_var_str
14985                    .into_iter()
14986                    .map(|p| ("site_id".to_owned(), p.to_string()))
14987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14988            ),
14989            _ => local_var_req_builder.query(&[(
14990                "site_id",
14991                &local_var_str
14992                    .into_iter()
14993                    .map(|p| p.to_string())
14994                    .collect::<Vec<String>>()
14995                    .join(",")
14996                    .to_string(),
14997            )]),
14998        };
14999    }
15000    if let Some(ref local_var_str) = site_id__n {
15001        local_var_req_builder = match "multi" {
15002            "multi" => local_var_req_builder.query(
15003                &local_var_str
15004                    .into_iter()
15005                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
15006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15007            ),
15008            _ => local_var_req_builder.query(&[(
15009                "site_id__n",
15010                &local_var_str
15011                    .into_iter()
15012                    .map(|p| p.to_string())
15013                    .collect::<Vec<String>>()
15014                    .join(",")
15015                    .to_string(),
15016            )]),
15017        };
15018    }
15019    if let Some(ref local_var_str) = start_on_boot {
15020        local_var_req_builder = match "multi" {
15021            "multi" => local_var_req_builder.query(
15022                &local_var_str
15023                    .into_iter()
15024                    .map(|p| ("start_on_boot".to_owned(), p.to_string()))
15025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15026            ),
15027            _ => local_var_req_builder.query(&[(
15028                "start_on_boot",
15029                &local_var_str
15030                    .into_iter()
15031                    .map(|p| p.to_string())
15032                    .collect::<Vec<String>>()
15033                    .join(",")
15034                    .to_string(),
15035            )]),
15036        };
15037    }
15038    if let Some(ref local_var_str) = start_on_boot__empty {
15039        local_var_req_builder =
15040            local_var_req_builder.query(&[("start_on_boot__empty", &local_var_str.to_string())]);
15041    }
15042    if let Some(ref local_var_str) = start_on_boot__ic {
15043        local_var_req_builder = match "multi" {
15044            "multi" => local_var_req_builder.query(
15045                &local_var_str
15046                    .into_iter()
15047                    .map(|p| ("start_on_boot__ic".to_owned(), p.to_string()))
15048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15049            ),
15050            _ => local_var_req_builder.query(&[(
15051                "start_on_boot__ic",
15052                &local_var_str
15053                    .into_iter()
15054                    .map(|p| p.to_string())
15055                    .collect::<Vec<String>>()
15056                    .join(",")
15057                    .to_string(),
15058            )]),
15059        };
15060    }
15061    if let Some(ref local_var_str) = start_on_boot__ie {
15062        local_var_req_builder = match "multi" {
15063            "multi" => local_var_req_builder.query(
15064                &local_var_str
15065                    .into_iter()
15066                    .map(|p| ("start_on_boot__ie".to_owned(), p.to_string()))
15067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15068            ),
15069            _ => local_var_req_builder.query(&[(
15070                "start_on_boot__ie",
15071                &local_var_str
15072                    .into_iter()
15073                    .map(|p| p.to_string())
15074                    .collect::<Vec<String>>()
15075                    .join(",")
15076                    .to_string(),
15077            )]),
15078        };
15079    }
15080    if let Some(ref local_var_str) = start_on_boot__iew {
15081        local_var_req_builder = match "multi" {
15082            "multi" => local_var_req_builder.query(
15083                &local_var_str
15084                    .into_iter()
15085                    .map(|p| ("start_on_boot__iew".to_owned(), p.to_string()))
15086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15087            ),
15088            _ => local_var_req_builder.query(&[(
15089                "start_on_boot__iew",
15090                &local_var_str
15091                    .into_iter()
15092                    .map(|p| p.to_string())
15093                    .collect::<Vec<String>>()
15094                    .join(",")
15095                    .to_string(),
15096            )]),
15097        };
15098    }
15099    if let Some(ref local_var_str) = start_on_boot__iregex {
15100        local_var_req_builder = match "multi" {
15101            "multi" => local_var_req_builder.query(
15102                &local_var_str
15103                    .into_iter()
15104                    .map(|p| ("start_on_boot__iregex".to_owned(), p.to_string()))
15105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15106            ),
15107            _ => local_var_req_builder.query(&[(
15108                "start_on_boot__iregex",
15109                &local_var_str
15110                    .into_iter()
15111                    .map(|p| p.to_string())
15112                    .collect::<Vec<String>>()
15113                    .join(",")
15114                    .to_string(),
15115            )]),
15116        };
15117    }
15118    if let Some(ref local_var_str) = start_on_boot__isw {
15119        local_var_req_builder = match "multi" {
15120            "multi" => local_var_req_builder.query(
15121                &local_var_str
15122                    .into_iter()
15123                    .map(|p| ("start_on_boot__isw".to_owned(), p.to_string()))
15124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15125            ),
15126            _ => local_var_req_builder.query(&[(
15127                "start_on_boot__isw",
15128                &local_var_str
15129                    .into_iter()
15130                    .map(|p| p.to_string())
15131                    .collect::<Vec<String>>()
15132                    .join(",")
15133                    .to_string(),
15134            )]),
15135        };
15136    }
15137    if let Some(ref local_var_str) = start_on_boot__n {
15138        local_var_req_builder = match "multi" {
15139            "multi" => local_var_req_builder.query(
15140                &local_var_str
15141                    .into_iter()
15142                    .map(|p| ("start_on_boot__n".to_owned(), p.to_string()))
15143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15144            ),
15145            _ => local_var_req_builder.query(&[(
15146                "start_on_boot__n",
15147                &local_var_str
15148                    .into_iter()
15149                    .map(|p| p.to_string())
15150                    .collect::<Vec<String>>()
15151                    .join(",")
15152                    .to_string(),
15153            )]),
15154        };
15155    }
15156    if let Some(ref local_var_str) = start_on_boot__nic {
15157        local_var_req_builder = match "multi" {
15158            "multi" => local_var_req_builder.query(
15159                &local_var_str
15160                    .into_iter()
15161                    .map(|p| ("start_on_boot__nic".to_owned(), p.to_string()))
15162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15163            ),
15164            _ => local_var_req_builder.query(&[(
15165                "start_on_boot__nic",
15166                &local_var_str
15167                    .into_iter()
15168                    .map(|p| p.to_string())
15169                    .collect::<Vec<String>>()
15170                    .join(",")
15171                    .to_string(),
15172            )]),
15173        };
15174    }
15175    if let Some(ref local_var_str) = start_on_boot__nie {
15176        local_var_req_builder = match "multi" {
15177            "multi" => local_var_req_builder.query(
15178                &local_var_str
15179                    .into_iter()
15180                    .map(|p| ("start_on_boot__nie".to_owned(), p.to_string()))
15181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15182            ),
15183            _ => local_var_req_builder.query(&[(
15184                "start_on_boot__nie",
15185                &local_var_str
15186                    .into_iter()
15187                    .map(|p| p.to_string())
15188                    .collect::<Vec<String>>()
15189                    .join(",")
15190                    .to_string(),
15191            )]),
15192        };
15193    }
15194    if let Some(ref local_var_str) = start_on_boot__niew {
15195        local_var_req_builder = match "multi" {
15196            "multi" => local_var_req_builder.query(
15197                &local_var_str
15198                    .into_iter()
15199                    .map(|p| ("start_on_boot__niew".to_owned(), p.to_string()))
15200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15201            ),
15202            _ => local_var_req_builder.query(&[(
15203                "start_on_boot__niew",
15204                &local_var_str
15205                    .into_iter()
15206                    .map(|p| p.to_string())
15207                    .collect::<Vec<String>>()
15208                    .join(",")
15209                    .to_string(),
15210            )]),
15211        };
15212    }
15213    if let Some(ref local_var_str) = start_on_boot__nisw {
15214        local_var_req_builder = match "multi" {
15215            "multi" => local_var_req_builder.query(
15216                &local_var_str
15217                    .into_iter()
15218                    .map(|p| ("start_on_boot__nisw".to_owned(), p.to_string()))
15219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15220            ),
15221            _ => local_var_req_builder.query(&[(
15222                "start_on_boot__nisw",
15223                &local_var_str
15224                    .into_iter()
15225                    .map(|p| p.to_string())
15226                    .collect::<Vec<String>>()
15227                    .join(",")
15228                    .to_string(),
15229            )]),
15230        };
15231    }
15232    if let Some(ref local_var_str) = start_on_boot__regex {
15233        local_var_req_builder = match "multi" {
15234            "multi" => local_var_req_builder.query(
15235                &local_var_str
15236                    .into_iter()
15237                    .map(|p| ("start_on_boot__regex".to_owned(), p.to_string()))
15238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15239            ),
15240            _ => local_var_req_builder.query(&[(
15241                "start_on_boot__regex",
15242                &local_var_str
15243                    .into_iter()
15244                    .map(|p| p.to_string())
15245                    .collect::<Vec<String>>()
15246                    .join(",")
15247                    .to_string(),
15248            )]),
15249        };
15250    }
15251    if let Some(ref local_var_str) = status {
15252        local_var_req_builder = match "multi" {
15253            "multi" => local_var_req_builder.query(
15254                &local_var_str
15255                    .into_iter()
15256                    .map(|p| ("status".to_owned(), p.to_string()))
15257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15258            ),
15259            _ => local_var_req_builder.query(&[(
15260                "status",
15261                &local_var_str
15262                    .into_iter()
15263                    .map(|p| p.to_string())
15264                    .collect::<Vec<String>>()
15265                    .join(",")
15266                    .to_string(),
15267            )]),
15268        };
15269    }
15270    if let Some(ref local_var_str) = status__empty {
15271        local_var_req_builder =
15272            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
15273    }
15274    if let Some(ref local_var_str) = status__ic {
15275        local_var_req_builder = match "multi" {
15276            "multi" => local_var_req_builder.query(
15277                &local_var_str
15278                    .into_iter()
15279                    .map(|p| ("status__ic".to_owned(), p.to_string()))
15280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15281            ),
15282            _ => local_var_req_builder.query(&[(
15283                "status__ic",
15284                &local_var_str
15285                    .into_iter()
15286                    .map(|p| p.to_string())
15287                    .collect::<Vec<String>>()
15288                    .join(",")
15289                    .to_string(),
15290            )]),
15291        };
15292    }
15293    if let Some(ref local_var_str) = status__ie {
15294        local_var_req_builder = match "multi" {
15295            "multi" => local_var_req_builder.query(
15296                &local_var_str
15297                    .into_iter()
15298                    .map(|p| ("status__ie".to_owned(), p.to_string()))
15299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15300            ),
15301            _ => local_var_req_builder.query(&[(
15302                "status__ie",
15303                &local_var_str
15304                    .into_iter()
15305                    .map(|p| p.to_string())
15306                    .collect::<Vec<String>>()
15307                    .join(",")
15308                    .to_string(),
15309            )]),
15310        };
15311    }
15312    if let Some(ref local_var_str) = status__iew {
15313        local_var_req_builder = match "multi" {
15314            "multi" => local_var_req_builder.query(
15315                &local_var_str
15316                    .into_iter()
15317                    .map(|p| ("status__iew".to_owned(), p.to_string()))
15318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15319            ),
15320            _ => local_var_req_builder.query(&[(
15321                "status__iew",
15322                &local_var_str
15323                    .into_iter()
15324                    .map(|p| p.to_string())
15325                    .collect::<Vec<String>>()
15326                    .join(",")
15327                    .to_string(),
15328            )]),
15329        };
15330    }
15331    if let Some(ref local_var_str) = status__iregex {
15332        local_var_req_builder = match "multi" {
15333            "multi" => local_var_req_builder.query(
15334                &local_var_str
15335                    .into_iter()
15336                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
15337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15338            ),
15339            _ => local_var_req_builder.query(&[(
15340                "status__iregex",
15341                &local_var_str
15342                    .into_iter()
15343                    .map(|p| p.to_string())
15344                    .collect::<Vec<String>>()
15345                    .join(",")
15346                    .to_string(),
15347            )]),
15348        };
15349    }
15350    if let Some(ref local_var_str) = status__isw {
15351        local_var_req_builder = match "multi" {
15352            "multi" => local_var_req_builder.query(
15353                &local_var_str
15354                    .into_iter()
15355                    .map(|p| ("status__isw".to_owned(), p.to_string()))
15356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15357            ),
15358            _ => local_var_req_builder.query(&[(
15359                "status__isw",
15360                &local_var_str
15361                    .into_iter()
15362                    .map(|p| p.to_string())
15363                    .collect::<Vec<String>>()
15364                    .join(",")
15365                    .to_string(),
15366            )]),
15367        };
15368    }
15369    if let Some(ref local_var_str) = status__n {
15370        local_var_req_builder = match "multi" {
15371            "multi" => local_var_req_builder.query(
15372                &local_var_str
15373                    .into_iter()
15374                    .map(|p| ("status__n".to_owned(), p.to_string()))
15375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15376            ),
15377            _ => local_var_req_builder.query(&[(
15378                "status__n",
15379                &local_var_str
15380                    .into_iter()
15381                    .map(|p| p.to_string())
15382                    .collect::<Vec<String>>()
15383                    .join(",")
15384                    .to_string(),
15385            )]),
15386        };
15387    }
15388    if let Some(ref local_var_str) = status__nic {
15389        local_var_req_builder = match "multi" {
15390            "multi" => local_var_req_builder.query(
15391                &local_var_str
15392                    .into_iter()
15393                    .map(|p| ("status__nic".to_owned(), p.to_string()))
15394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15395            ),
15396            _ => local_var_req_builder.query(&[(
15397                "status__nic",
15398                &local_var_str
15399                    .into_iter()
15400                    .map(|p| p.to_string())
15401                    .collect::<Vec<String>>()
15402                    .join(",")
15403                    .to_string(),
15404            )]),
15405        };
15406    }
15407    if let Some(ref local_var_str) = status__nie {
15408        local_var_req_builder = match "multi" {
15409            "multi" => local_var_req_builder.query(
15410                &local_var_str
15411                    .into_iter()
15412                    .map(|p| ("status__nie".to_owned(), p.to_string()))
15413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15414            ),
15415            _ => local_var_req_builder.query(&[(
15416                "status__nie",
15417                &local_var_str
15418                    .into_iter()
15419                    .map(|p| p.to_string())
15420                    .collect::<Vec<String>>()
15421                    .join(",")
15422                    .to_string(),
15423            )]),
15424        };
15425    }
15426    if let Some(ref local_var_str) = status__niew {
15427        local_var_req_builder = match "multi" {
15428            "multi" => local_var_req_builder.query(
15429                &local_var_str
15430                    .into_iter()
15431                    .map(|p| ("status__niew".to_owned(), p.to_string()))
15432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15433            ),
15434            _ => local_var_req_builder.query(&[(
15435                "status__niew",
15436                &local_var_str
15437                    .into_iter()
15438                    .map(|p| p.to_string())
15439                    .collect::<Vec<String>>()
15440                    .join(",")
15441                    .to_string(),
15442            )]),
15443        };
15444    }
15445    if let Some(ref local_var_str) = status__nisw {
15446        local_var_req_builder = match "multi" {
15447            "multi" => local_var_req_builder.query(
15448                &local_var_str
15449                    .into_iter()
15450                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
15451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15452            ),
15453            _ => local_var_req_builder.query(&[(
15454                "status__nisw",
15455                &local_var_str
15456                    .into_iter()
15457                    .map(|p| p.to_string())
15458                    .collect::<Vec<String>>()
15459                    .join(",")
15460                    .to_string(),
15461            )]),
15462        };
15463    }
15464    if let Some(ref local_var_str) = status__regex {
15465        local_var_req_builder = match "multi" {
15466            "multi" => local_var_req_builder.query(
15467                &local_var_str
15468                    .into_iter()
15469                    .map(|p| ("status__regex".to_owned(), p.to_string()))
15470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15471            ),
15472            _ => local_var_req_builder.query(&[(
15473                "status__regex",
15474                &local_var_str
15475                    .into_iter()
15476                    .map(|p| p.to_string())
15477                    .collect::<Vec<String>>()
15478                    .join(",")
15479                    .to_string(),
15480            )]),
15481        };
15482    }
15483    if let Some(ref local_var_str) = tag {
15484        local_var_req_builder = match "multi" {
15485            "multi" => local_var_req_builder.query(
15486                &local_var_str
15487                    .into_iter()
15488                    .map(|p| ("tag".to_owned(), p.to_string()))
15489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15490            ),
15491            _ => local_var_req_builder.query(&[(
15492                "tag",
15493                &local_var_str
15494                    .into_iter()
15495                    .map(|p| p.to_string())
15496                    .collect::<Vec<String>>()
15497                    .join(",")
15498                    .to_string(),
15499            )]),
15500        };
15501    }
15502    if let Some(ref local_var_str) = tag__n {
15503        local_var_req_builder = match "multi" {
15504            "multi" => local_var_req_builder.query(
15505                &local_var_str
15506                    .into_iter()
15507                    .map(|p| ("tag__n".to_owned(), p.to_string()))
15508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15509            ),
15510            _ => local_var_req_builder.query(&[(
15511                "tag__n",
15512                &local_var_str
15513                    .into_iter()
15514                    .map(|p| p.to_string())
15515                    .collect::<Vec<String>>()
15516                    .join(",")
15517                    .to_string(),
15518            )]),
15519        };
15520    }
15521    if let Some(ref local_var_str) = tag_id {
15522        local_var_req_builder = match "multi" {
15523            "multi" => local_var_req_builder.query(
15524                &local_var_str
15525                    .into_iter()
15526                    .map(|p| ("tag_id".to_owned(), p.to_string()))
15527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15528            ),
15529            _ => local_var_req_builder.query(&[(
15530                "tag_id",
15531                &local_var_str
15532                    .into_iter()
15533                    .map(|p| p.to_string())
15534                    .collect::<Vec<String>>()
15535                    .join(",")
15536                    .to_string(),
15537            )]),
15538        };
15539    }
15540    if let Some(ref local_var_str) = tag_id__n {
15541        local_var_req_builder = match "multi" {
15542            "multi" => local_var_req_builder.query(
15543                &local_var_str
15544                    .into_iter()
15545                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
15546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15547            ),
15548            _ => local_var_req_builder.query(&[(
15549                "tag_id__n",
15550                &local_var_str
15551                    .into_iter()
15552                    .map(|p| p.to_string())
15553                    .collect::<Vec<String>>()
15554                    .join(",")
15555                    .to_string(),
15556            )]),
15557        };
15558    }
15559    if let Some(ref local_var_str) = tenant {
15560        local_var_req_builder = match "multi" {
15561            "multi" => local_var_req_builder.query(
15562                &local_var_str
15563                    .into_iter()
15564                    .map(|p| ("tenant".to_owned(), p.to_string()))
15565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15566            ),
15567            _ => local_var_req_builder.query(&[(
15568                "tenant",
15569                &local_var_str
15570                    .into_iter()
15571                    .map(|p| p.to_string())
15572                    .collect::<Vec<String>>()
15573                    .join(",")
15574                    .to_string(),
15575            )]),
15576        };
15577    }
15578    if let Some(ref local_var_str) = tenant__n {
15579        local_var_req_builder = match "multi" {
15580            "multi" => local_var_req_builder.query(
15581                &local_var_str
15582                    .into_iter()
15583                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
15584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15585            ),
15586            _ => local_var_req_builder.query(&[(
15587                "tenant__n",
15588                &local_var_str
15589                    .into_iter()
15590                    .map(|p| p.to_string())
15591                    .collect::<Vec<String>>()
15592                    .join(",")
15593                    .to_string(),
15594            )]),
15595        };
15596    }
15597    if let Some(ref local_var_str) = tenant_group {
15598        local_var_req_builder = match "multi" {
15599            "multi" => local_var_req_builder.query(
15600                &local_var_str
15601                    .into_iter()
15602                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
15603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15604            ),
15605            _ => local_var_req_builder.query(&[(
15606                "tenant_group",
15607                &local_var_str
15608                    .into_iter()
15609                    .map(|p| p.to_string())
15610                    .collect::<Vec<String>>()
15611                    .join(",")
15612                    .to_string(),
15613            )]),
15614        };
15615    }
15616    if let Some(ref local_var_str) = tenant_group__n {
15617        local_var_req_builder = match "multi" {
15618            "multi" => local_var_req_builder.query(
15619                &local_var_str
15620                    .into_iter()
15621                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
15622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15623            ),
15624            _ => local_var_req_builder.query(&[(
15625                "tenant_group__n",
15626                &local_var_str
15627                    .into_iter()
15628                    .map(|p| p.to_string())
15629                    .collect::<Vec<String>>()
15630                    .join(",")
15631                    .to_string(),
15632            )]),
15633        };
15634    }
15635    if let Some(ref local_var_str) = tenant_group_id {
15636        local_var_req_builder = match "multi" {
15637            "multi" => local_var_req_builder.query(
15638                &local_var_str
15639                    .into_iter()
15640                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
15641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15642            ),
15643            _ => local_var_req_builder.query(&[(
15644                "tenant_group_id",
15645                &local_var_str
15646                    .into_iter()
15647                    .map(|p| p.to_string())
15648                    .collect::<Vec<String>>()
15649                    .join(",")
15650                    .to_string(),
15651            )]),
15652        };
15653    }
15654    if let Some(ref local_var_str) = tenant_group_id__n {
15655        local_var_req_builder = match "multi" {
15656            "multi" => local_var_req_builder.query(
15657                &local_var_str
15658                    .into_iter()
15659                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
15660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15661            ),
15662            _ => local_var_req_builder.query(&[(
15663                "tenant_group_id__n",
15664                &local_var_str
15665                    .into_iter()
15666                    .map(|p| p.to_string())
15667                    .collect::<Vec<String>>()
15668                    .join(",")
15669                    .to_string(),
15670            )]),
15671        };
15672    }
15673    if let Some(ref local_var_str) = tenant_id {
15674        local_var_req_builder = match "multi" {
15675            "multi" => local_var_req_builder.query(
15676                &local_var_str
15677                    .into_iter()
15678                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
15679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15680            ),
15681            _ => local_var_req_builder.query(&[(
15682                "tenant_id",
15683                &local_var_str
15684                    .into_iter()
15685                    .map(|p| p.to_string())
15686                    .collect::<Vec<String>>()
15687                    .join(",")
15688                    .to_string(),
15689            )]),
15690        };
15691    }
15692    if let Some(ref local_var_str) = tenant_id__n {
15693        local_var_req_builder = match "multi" {
15694            "multi" => local_var_req_builder.query(
15695                &local_var_str
15696                    .into_iter()
15697                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
15698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15699            ),
15700            _ => local_var_req_builder.query(&[(
15701                "tenant_id__n",
15702                &local_var_str
15703                    .into_iter()
15704                    .map(|p| p.to_string())
15705                    .collect::<Vec<String>>()
15706                    .join(",")
15707                    .to_string(),
15708            )]),
15709        };
15710    }
15711    if let Some(ref local_var_str) = updated_by_request {
15712        local_var_req_builder =
15713            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
15714    }
15715    if let Some(ref local_var_str) = vcpus {
15716        local_var_req_builder = match "multi" {
15717            "multi" => local_var_req_builder.query(
15718                &local_var_str
15719                    .into_iter()
15720                    .map(|p| ("vcpus".to_owned(), p.to_string()))
15721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15722            ),
15723            _ => local_var_req_builder.query(&[(
15724                "vcpus",
15725                &local_var_str
15726                    .into_iter()
15727                    .map(|p| p.to_string())
15728                    .collect::<Vec<String>>()
15729                    .join(",")
15730                    .to_string(),
15731            )]),
15732        };
15733    }
15734    if let Some(ref local_var_str) = vcpus__empty {
15735        local_var_req_builder =
15736            local_var_req_builder.query(&[("vcpus__empty", &local_var_str.to_string())]);
15737    }
15738    if let Some(ref local_var_str) = vcpus__gt {
15739        local_var_req_builder = match "multi" {
15740            "multi" => local_var_req_builder.query(
15741                &local_var_str
15742                    .into_iter()
15743                    .map(|p| ("vcpus__gt".to_owned(), p.to_string()))
15744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15745            ),
15746            _ => local_var_req_builder.query(&[(
15747                "vcpus__gt",
15748                &local_var_str
15749                    .into_iter()
15750                    .map(|p| p.to_string())
15751                    .collect::<Vec<String>>()
15752                    .join(",")
15753                    .to_string(),
15754            )]),
15755        };
15756    }
15757    if let Some(ref local_var_str) = vcpus__gte {
15758        local_var_req_builder = match "multi" {
15759            "multi" => local_var_req_builder.query(
15760                &local_var_str
15761                    .into_iter()
15762                    .map(|p| ("vcpus__gte".to_owned(), p.to_string()))
15763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15764            ),
15765            _ => local_var_req_builder.query(&[(
15766                "vcpus__gte",
15767                &local_var_str
15768                    .into_iter()
15769                    .map(|p| p.to_string())
15770                    .collect::<Vec<String>>()
15771                    .join(",")
15772                    .to_string(),
15773            )]),
15774        };
15775    }
15776    if let Some(ref local_var_str) = vcpus__lt {
15777        local_var_req_builder = match "multi" {
15778            "multi" => local_var_req_builder.query(
15779                &local_var_str
15780                    .into_iter()
15781                    .map(|p| ("vcpus__lt".to_owned(), p.to_string()))
15782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15783            ),
15784            _ => local_var_req_builder.query(&[(
15785                "vcpus__lt",
15786                &local_var_str
15787                    .into_iter()
15788                    .map(|p| p.to_string())
15789                    .collect::<Vec<String>>()
15790                    .join(",")
15791                    .to_string(),
15792            )]),
15793        };
15794    }
15795    if let Some(ref local_var_str) = vcpus__lte {
15796        local_var_req_builder = match "multi" {
15797            "multi" => local_var_req_builder.query(
15798                &local_var_str
15799                    .into_iter()
15800                    .map(|p| ("vcpus__lte".to_owned(), p.to_string()))
15801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15802            ),
15803            _ => local_var_req_builder.query(&[(
15804                "vcpus__lte",
15805                &local_var_str
15806                    .into_iter()
15807                    .map(|p| p.to_string())
15808                    .collect::<Vec<String>>()
15809                    .join(",")
15810                    .to_string(),
15811            )]),
15812        };
15813    }
15814    if let Some(ref local_var_str) = vcpus__n {
15815        local_var_req_builder = match "multi" {
15816            "multi" => local_var_req_builder.query(
15817                &local_var_str
15818                    .into_iter()
15819                    .map(|p| ("vcpus__n".to_owned(), p.to_string()))
15820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15821            ),
15822            _ => local_var_req_builder.query(&[(
15823                "vcpus__n",
15824                &local_var_str
15825                    .into_iter()
15826                    .map(|p| p.to_string())
15827                    .collect::<Vec<String>>()
15828                    .join(",")
15829                    .to_string(),
15830            )]),
15831        };
15832    }
15833    if let Some(ref local_var_str) = virtual_disk_count {
15834        local_var_req_builder = match "multi" {
15835            "multi" => local_var_req_builder.query(
15836                &local_var_str
15837                    .into_iter()
15838                    .map(|p| ("virtual_disk_count".to_owned(), p.to_string()))
15839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15840            ),
15841            _ => local_var_req_builder.query(&[(
15842                "virtual_disk_count",
15843                &local_var_str
15844                    .into_iter()
15845                    .map(|p| p.to_string())
15846                    .collect::<Vec<String>>()
15847                    .join(",")
15848                    .to_string(),
15849            )]),
15850        };
15851    }
15852    if let Some(ref local_var_str) = virtual_disk_count__empty {
15853        local_var_req_builder = local_var_req_builder
15854            .query(&[("virtual_disk_count__empty", &local_var_str.to_string())]);
15855    }
15856    if let Some(ref local_var_str) = virtual_disk_count__gt {
15857        local_var_req_builder = match "multi" {
15858            "multi" => local_var_req_builder.query(
15859                &local_var_str
15860                    .into_iter()
15861                    .map(|p| ("virtual_disk_count__gt".to_owned(), p.to_string()))
15862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15863            ),
15864            _ => local_var_req_builder.query(&[(
15865                "virtual_disk_count__gt",
15866                &local_var_str
15867                    .into_iter()
15868                    .map(|p| p.to_string())
15869                    .collect::<Vec<String>>()
15870                    .join(",")
15871                    .to_string(),
15872            )]),
15873        };
15874    }
15875    if let Some(ref local_var_str) = virtual_disk_count__gte {
15876        local_var_req_builder = match "multi" {
15877            "multi" => local_var_req_builder.query(
15878                &local_var_str
15879                    .into_iter()
15880                    .map(|p| ("virtual_disk_count__gte".to_owned(), p.to_string()))
15881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15882            ),
15883            _ => local_var_req_builder.query(&[(
15884                "virtual_disk_count__gte",
15885                &local_var_str
15886                    .into_iter()
15887                    .map(|p| p.to_string())
15888                    .collect::<Vec<String>>()
15889                    .join(",")
15890                    .to_string(),
15891            )]),
15892        };
15893    }
15894    if let Some(ref local_var_str) = virtual_disk_count__lt {
15895        local_var_req_builder = match "multi" {
15896            "multi" => local_var_req_builder.query(
15897                &local_var_str
15898                    .into_iter()
15899                    .map(|p| ("virtual_disk_count__lt".to_owned(), p.to_string()))
15900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15901            ),
15902            _ => local_var_req_builder.query(&[(
15903                "virtual_disk_count__lt",
15904                &local_var_str
15905                    .into_iter()
15906                    .map(|p| p.to_string())
15907                    .collect::<Vec<String>>()
15908                    .join(",")
15909                    .to_string(),
15910            )]),
15911        };
15912    }
15913    if let Some(ref local_var_str) = virtual_disk_count__lte {
15914        local_var_req_builder = match "multi" {
15915            "multi" => local_var_req_builder.query(
15916                &local_var_str
15917                    .into_iter()
15918                    .map(|p| ("virtual_disk_count__lte".to_owned(), p.to_string()))
15919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15920            ),
15921            _ => local_var_req_builder.query(&[(
15922                "virtual_disk_count__lte",
15923                &local_var_str
15924                    .into_iter()
15925                    .map(|p| p.to_string())
15926                    .collect::<Vec<String>>()
15927                    .join(",")
15928                    .to_string(),
15929            )]),
15930        };
15931    }
15932    if let Some(ref local_var_str) = virtual_disk_count__n {
15933        local_var_req_builder = match "multi" {
15934            "multi" => local_var_req_builder.query(
15935                &local_var_str
15936                    .into_iter()
15937                    .map(|p| ("virtual_disk_count__n".to_owned(), p.to_string()))
15938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15939            ),
15940            _ => local_var_req_builder.query(&[(
15941                "virtual_disk_count__n",
15942                &local_var_str
15943                    .into_iter()
15944                    .map(|p| p.to_string())
15945                    .collect::<Vec<String>>()
15946                    .join(",")
15947                    .to_string(),
15948            )]),
15949        };
15950    }
15951    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15952        local_var_req_builder =
15953            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15954    }
15955    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15956        let local_var_key = local_var_apikey.key.clone();
15957        let local_var_value = match local_var_apikey.prefix {
15958            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15959            None => local_var_key,
15960        };
15961        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15962    };
15963
15964    let local_var_req = local_var_req_builder.build()?;
15965    let local_var_resp = local_var_client.execute(local_var_req).await?;
15966
15967    let local_var_status = local_var_resp.status();
15968    let local_var_content = local_var_resp.text().await?;
15969
15970    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15971        serde_json::from_str(&local_var_content).map_err(Error::from)
15972    } else {
15973        let local_var_entity: Option<VirtualizationVirtualMachinesListError> =
15974            serde_json::from_str(&local_var_content).ok();
15975        let local_var_error = ResponseContent {
15976            status: local_var_status,
15977            content: local_var_content,
15978            entity: local_var_entity,
15979        };
15980        Err(Error::ResponseError(local_var_error))
15981    }
15982}
15983
15984/// Patch a virtual machine object.
15985pub async fn virtualization_virtual_machines_partial_update(
15986    configuration: &configuration::Configuration,
15987    id: i32,
15988    patched_writable_virtual_machine_with_config_context_request: Option<
15989        crate::models::PatchedWritableVirtualMachineWithConfigContextRequest,
15990    >,
15991) -> Result<
15992    crate::models::VirtualMachineWithConfigContext,
15993    Error<VirtualizationVirtualMachinesPartialUpdateError>,
15994> {
15995    let local_var_configuration = configuration;
15996
15997    let local_var_client = &local_var_configuration.client;
15998
15999    let local_var_uri_str = format!(
16000        "{}/api/virtualization/virtual-machines/{id}/",
16001        local_var_configuration.base_path,
16002        id = id
16003    );
16004    let mut local_var_req_builder =
16005        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16006
16007    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16008        local_var_req_builder =
16009            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16010    }
16011    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16012        let local_var_key = local_var_apikey.key.clone();
16013        let local_var_value = match local_var_apikey.prefix {
16014            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16015            None => local_var_key,
16016        };
16017        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16018    };
16019    local_var_req_builder =
16020        local_var_req_builder.json(&patched_writable_virtual_machine_with_config_context_request);
16021
16022    let local_var_req = local_var_req_builder.build()?;
16023    let local_var_resp = local_var_client.execute(local_var_req).await?;
16024
16025    let local_var_status = local_var_resp.status();
16026    let local_var_content = local_var_resp.text().await?;
16027
16028    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16029        serde_json::from_str(&local_var_content).map_err(Error::from)
16030    } else {
16031        let local_var_entity: Option<VirtualizationVirtualMachinesPartialUpdateError> =
16032            serde_json::from_str(&local_var_content).ok();
16033        let local_var_error = ResponseContent {
16034            status: local_var_status,
16035            content: local_var_content,
16036            entity: local_var_entity,
16037        };
16038        Err(Error::ResponseError(local_var_error))
16039    }
16040}
16041
16042/// Resolve and render the preferred ConfigTemplate for this Device or Virtual Machine.
16043pub async fn virtualization_virtual_machines_render_config_create(
16044    configuration: &configuration::Configuration,
16045    id: i32,
16046    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
16047    format: Option<&str>,
16048) -> Result<
16049    crate::models::VirtualMachineWithConfigContext,
16050    Error<VirtualizationVirtualMachinesRenderConfigCreateError>,
16051> {
16052    let local_var_configuration = configuration;
16053
16054    let local_var_client = &local_var_configuration.client;
16055
16056    let local_var_uri_str = format!(
16057        "{}/api/virtualization/virtual-machines/{id}/render-config/",
16058        local_var_configuration.base_path,
16059        id = id
16060    );
16061    let mut local_var_req_builder =
16062        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
16063
16064    if let Some(ref local_var_str) = format {
16065        local_var_req_builder =
16066            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16067    }
16068    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16069        local_var_req_builder =
16070            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16071    }
16072    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16073        let local_var_key = local_var_apikey.key.clone();
16074        let local_var_value = match local_var_apikey.prefix {
16075            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16076            None => local_var_key,
16077        };
16078        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16079    };
16080    local_var_req_builder =
16081        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
16082
16083    let local_var_req = local_var_req_builder.build()?;
16084    let local_var_resp = local_var_client.execute(local_var_req).await?;
16085
16086    let local_var_status = local_var_resp.status();
16087    let local_var_content = local_var_resp.text().await?;
16088
16089    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16090        serde_json::from_str(&local_var_content).map_err(Error::from)
16091    } else {
16092        let local_var_entity: Option<VirtualizationVirtualMachinesRenderConfigCreateError> =
16093            serde_json::from_str(&local_var_content).ok();
16094        let local_var_error = ResponseContent {
16095            status: local_var_status,
16096            content: local_var_content,
16097            entity: local_var_entity,
16098        };
16099        Err(Error::ResponseError(local_var_error))
16100    }
16101}
16102
16103/// Get a virtual machine object.
16104pub async fn virtualization_virtual_machines_retrieve(
16105    configuration: &configuration::Configuration,
16106    id: i32,
16107) -> Result<
16108    crate::models::VirtualMachineWithConfigContext,
16109    Error<VirtualizationVirtualMachinesRetrieveError>,
16110> {
16111    let local_var_configuration = configuration;
16112
16113    let local_var_client = &local_var_configuration.client;
16114
16115    let local_var_uri_str = format!(
16116        "{}/api/virtualization/virtual-machines/{id}/",
16117        local_var_configuration.base_path,
16118        id = id
16119    );
16120    let mut local_var_req_builder =
16121        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16122
16123    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16124        local_var_req_builder =
16125            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16126    }
16127    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16128        let local_var_key = local_var_apikey.key.clone();
16129        let local_var_value = match local_var_apikey.prefix {
16130            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16131            None => local_var_key,
16132        };
16133        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16134    };
16135
16136    let local_var_req = local_var_req_builder.build()?;
16137    let local_var_resp = local_var_client.execute(local_var_req).await?;
16138
16139    let local_var_status = local_var_resp.status();
16140    let local_var_content = local_var_resp.text().await?;
16141
16142    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16143        serde_json::from_str(&local_var_content).map_err(Error::from)
16144    } else {
16145        let local_var_entity: Option<VirtualizationVirtualMachinesRetrieveError> =
16146            serde_json::from_str(&local_var_content).ok();
16147        let local_var_error = ResponseContent {
16148            status: local_var_status,
16149            content: local_var_content,
16150            entity: local_var_entity,
16151        };
16152        Err(Error::ResponseError(local_var_error))
16153    }
16154}
16155
16156/// Put a virtual machine object.
16157pub async fn virtualization_virtual_machines_update(
16158    configuration: &configuration::Configuration,
16159    id: i32,
16160    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
16161) -> Result<
16162    crate::models::VirtualMachineWithConfigContext,
16163    Error<VirtualizationVirtualMachinesUpdateError>,
16164> {
16165    let local_var_configuration = configuration;
16166
16167    let local_var_client = &local_var_configuration.client;
16168
16169    let local_var_uri_str = format!(
16170        "{}/api/virtualization/virtual-machines/{id}/",
16171        local_var_configuration.base_path,
16172        id = id
16173    );
16174    let mut local_var_req_builder =
16175        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
16176
16177    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16178        local_var_req_builder =
16179            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16180    }
16181    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16182        let local_var_key = local_var_apikey.key.clone();
16183        let local_var_value = match local_var_apikey.prefix {
16184            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16185            None => local_var_key,
16186        };
16187        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16188    };
16189    local_var_req_builder =
16190        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
16191
16192    let local_var_req = local_var_req_builder.build()?;
16193    let local_var_resp = local_var_client.execute(local_var_req).await?;
16194
16195    let local_var_status = local_var_resp.status();
16196    let local_var_content = local_var_resp.text().await?;
16197
16198    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16199        serde_json::from_str(&local_var_content).map_err(Error::from)
16200    } else {
16201        let local_var_entity: Option<VirtualizationVirtualMachinesUpdateError> =
16202            serde_json::from_str(&local_var_content).ok();
16203        let local_var_error = ResponseContent {
16204            status: local_var_status,
16205            content: local_var_content,
16206            entity: local_var_entity,
16207        };
16208        Err(Error::ResponseError(local_var_error))
16209    }
16210}
netbox_openapi/apis/virtualization_api.rs

netbox_openapi/apis/
virtualization_api.rs
