nautobot_openapi/apis/
tenancy_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`tenancy_tenant_groups_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum TenancyTenantGroupsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`tenancy_tenant_groups_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum TenancyTenantGroupsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`tenancy_tenant_groups_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum TenancyTenantGroupsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`tenancy_tenant_groups_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum TenancyTenantGroupsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`tenancy_tenant_groups_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum TenancyTenantGroupsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`tenancy_tenant_groups_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum TenancyTenantGroupsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`tenancy_tenant_groups_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum TenancyTenantGroupsNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`tenancy_tenant_groups_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum TenancyTenantGroupsNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`tenancy_tenant_groups_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum TenancyTenantGroupsPartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`tenancy_tenant_groups_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum TenancyTenantGroupsRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`tenancy_tenant_groups_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum TenancyTenantGroupsUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`tenancy_tenants_bulk_destroy`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum TenancyTenantsBulkDestroyError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`tenancy_tenants_bulk_partial_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum TenancyTenantsBulkPartialUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`tenancy_tenants_bulk_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum TenancyTenantsBulkUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`tenancy_tenants_create`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum TenancyTenantsCreateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`tenancy_tenants_destroy`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum TenancyTenantsDestroyError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`tenancy_tenants_list`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum TenancyTenantsListError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`tenancy_tenants_notes_create`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum TenancyTenantsNotesCreateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`tenancy_tenants_notes_list`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum TenancyTenantsNotesListError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`tenancy_tenants_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum TenancyTenantsPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`tenancy_tenants_retrieve`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum TenancyTenantsRetrieveError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`tenancy_tenants_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum TenancyTenantsUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// Destroy a list of tenant group objects.
171pub async fn tenancy_tenant_groups_bulk_destroy(
172    configuration: &configuration::Configuration,
173    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
174    format: Option<&str>,
175) -> Result<(), Error<TenancyTenantGroupsBulkDestroyError>> {
176    let local_var_configuration = configuration;
177
178    let local_var_client = &local_var_configuration.client;
179
180    let local_var_uri_str = format!(
181        "{}/tenancy/tenant-groups/",
182        local_var_configuration.base_path
183    );
184    let mut local_var_req_builder =
185        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
186
187    if let Some(ref local_var_str) = format {
188        local_var_req_builder =
189            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
190    }
191    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
192        local_var_req_builder =
193            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
194    }
195    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
196        let local_var_key = local_var_apikey.key.clone();
197        let local_var_value = match local_var_apikey.prefix {
198            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
199            None => local_var_key,
200        };
201        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
202    };
203    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
204
205    let local_var_req = local_var_req_builder.build()?;
206    let local_var_resp = local_var_client.execute(local_var_req).await?;
207
208    let local_var_status = local_var_resp.status();
209    let local_var_content = local_var_resp.text().await?;
210
211    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
212        Ok(())
213    } else {
214        let local_var_entity: Option<TenancyTenantGroupsBulkDestroyError> =
215            serde_json::from_str(&local_var_content).ok();
216        let local_var_error = ResponseContent {
217            status: local_var_status,
218            content: local_var_content,
219            entity: local_var_entity,
220        };
221        Err(Error::ResponseError(local_var_error))
222    }
223}
224
225/// Partial update a list of tenant group objects.
226pub async fn tenancy_tenant_groups_bulk_partial_update(
227    configuration: &configuration::Configuration,
228    patched_bulk_writable_tenant_group_request: Vec<
229        crate::models::PatchedBulkWritableTenantGroupRequest,
230    >,
231    format: Option<&str>,
232) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkPartialUpdateError>> {
233    let local_var_configuration = configuration;
234
235    let local_var_client = &local_var_configuration.client;
236
237    let local_var_uri_str = format!(
238        "{}/tenancy/tenant-groups/",
239        local_var_configuration.base_path
240    );
241    let mut local_var_req_builder =
242        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
243
244    if let Some(ref local_var_str) = format {
245        local_var_req_builder =
246            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
247    }
248    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
249        local_var_req_builder =
250            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
251    }
252    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
253        let local_var_key = local_var_apikey.key.clone();
254        let local_var_value = match local_var_apikey.prefix {
255            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
256            None => local_var_key,
257        };
258        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
259    };
260    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_tenant_group_request);
261
262    let local_var_req = local_var_req_builder.build()?;
263    let local_var_resp = local_var_client.execute(local_var_req).await?;
264
265    let local_var_status = local_var_resp.status();
266    let local_var_content = local_var_resp.text().await?;
267
268    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
269        serde_json::from_str(&local_var_content).map_err(Error::from)
270    } else {
271        let local_var_entity: Option<TenancyTenantGroupsBulkPartialUpdateError> =
272            serde_json::from_str(&local_var_content).ok();
273        let local_var_error = ResponseContent {
274            status: local_var_status,
275            content: local_var_content,
276            entity: local_var_entity,
277        };
278        Err(Error::ResponseError(local_var_error))
279    }
280}
281
282/// Update a list of tenant group objects.
283pub async fn tenancy_tenant_groups_bulk_update(
284    configuration: &configuration::Configuration,
285    bulk_writable_tenant_group_request: Vec<crate::models::BulkWritableTenantGroupRequest>,
286    format: Option<&str>,
287) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkUpdateError>> {
288    let local_var_configuration = configuration;
289
290    let local_var_client = &local_var_configuration.client;
291
292    let local_var_uri_str = format!(
293        "{}/tenancy/tenant-groups/",
294        local_var_configuration.base_path
295    );
296    let mut local_var_req_builder =
297        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
298
299    if let Some(ref local_var_str) = format {
300        local_var_req_builder =
301            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
302    }
303    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
304        local_var_req_builder =
305            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
306    }
307    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
308        let local_var_key = local_var_apikey.key.clone();
309        let local_var_value = match local_var_apikey.prefix {
310            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
311            None => local_var_key,
312        };
313        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
314    };
315    local_var_req_builder = local_var_req_builder.json(&bulk_writable_tenant_group_request);
316
317    let local_var_req = local_var_req_builder.build()?;
318    let local_var_resp = local_var_client.execute(local_var_req).await?;
319
320    let local_var_status = local_var_resp.status();
321    let local_var_content = local_var_resp.text().await?;
322
323    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
324        serde_json::from_str(&local_var_content).map_err(Error::from)
325    } else {
326        let local_var_entity: Option<TenancyTenantGroupsBulkUpdateError> =
327            serde_json::from_str(&local_var_content).ok();
328        let local_var_error = ResponseContent {
329            status: local_var_status,
330            content: local_var_content,
331            entity: local_var_entity,
332        };
333        Err(Error::ResponseError(local_var_error))
334    }
335}
336
337/// Create one or more tenant group objects.
338pub async fn tenancy_tenant_groups_create(
339    configuration: &configuration::Configuration,
340    tenant_group_request: crate::models::TenantGroupRequest,
341    format: Option<&str>,
342) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsCreateError>> {
343    let local_var_configuration = configuration;
344
345    let local_var_client = &local_var_configuration.client;
346
347    let local_var_uri_str = format!(
348        "{}/tenancy/tenant-groups/",
349        local_var_configuration.base_path
350    );
351    let mut local_var_req_builder =
352        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
353
354    if let Some(ref local_var_str) = format {
355        local_var_req_builder =
356            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
357    }
358    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
359        local_var_req_builder =
360            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
361    }
362    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
363        let local_var_key = local_var_apikey.key.clone();
364        let local_var_value = match local_var_apikey.prefix {
365            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
366            None => local_var_key,
367        };
368        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
369    };
370    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
371
372    let local_var_req = local_var_req_builder.build()?;
373    let local_var_resp = local_var_client.execute(local_var_req).await?;
374
375    let local_var_status = local_var_resp.status();
376    let local_var_content = local_var_resp.text().await?;
377
378    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
379        serde_json::from_str(&local_var_content).map_err(Error::from)
380    } else {
381        let local_var_entity: Option<TenancyTenantGroupsCreateError> =
382            serde_json::from_str(&local_var_content).ok();
383        let local_var_error = ResponseContent {
384            status: local_var_status,
385            content: local_var_content,
386            entity: local_var_entity,
387        };
388        Err(Error::ResponseError(local_var_error))
389    }
390}
391
392/// Destroy a tenant group object.
393pub async fn tenancy_tenant_groups_destroy(
394    configuration: &configuration::Configuration,
395    id: &str,
396    format: Option<&str>,
397) -> Result<(), Error<TenancyTenantGroupsDestroyError>> {
398    let local_var_configuration = configuration;
399
400    let local_var_client = &local_var_configuration.client;
401
402    let local_var_uri_str = format!(
403        "{}/tenancy/tenant-groups/{id}/",
404        local_var_configuration.base_path,
405        id = crate::apis::urlencode(id)
406    );
407    let mut local_var_req_builder =
408        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
409
410    if let Some(ref local_var_str) = format {
411        local_var_req_builder =
412            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
413    }
414    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
415        local_var_req_builder =
416            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
417    }
418    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
419        let local_var_key = local_var_apikey.key.clone();
420        let local_var_value = match local_var_apikey.prefix {
421            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
422            None => local_var_key,
423        };
424        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
425    };
426
427    let local_var_req = local_var_req_builder.build()?;
428    let local_var_resp = local_var_client.execute(local_var_req).await?;
429
430    let local_var_status = local_var_resp.status();
431    let local_var_content = local_var_resp.text().await?;
432
433    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
434        Ok(())
435    } else {
436        let local_var_entity: Option<TenancyTenantGroupsDestroyError> =
437            serde_json::from_str(&local_var_content).ok();
438        let local_var_error = ResponseContent {
439            status: local_var_status,
440            content: local_var_content,
441            entity: local_var_entity,
442        };
443        Err(Error::ResponseError(local_var_error))
444    }
445}
446
447/// Retrieve a list of tenant group objects.
448pub async fn tenancy_tenant_groups_list(
449    configuration: &configuration::Configuration,
450    children: Option<Vec<String>>,
451    children__isnull: Option<bool>,
452    children__n: Option<Vec<String>>,
453    contacts: Option<Vec<String>>,
454    contacts__isnull: Option<bool>,
455    contacts__n: Option<Vec<String>>,
456    created: Option<Vec<String>>,
457    created__gt: Option<Vec<String>>,
458    created__gte: Option<Vec<String>>,
459    created__isnull: Option<bool>,
460    created__lt: Option<Vec<String>>,
461    created__lte: Option<Vec<String>>,
462    created__n: Option<Vec<String>>,
463    description: Option<Vec<String>>,
464    description__ic: Option<Vec<String>>,
465    description__ie: Option<Vec<String>>,
466    description__iew: Option<Vec<String>>,
467    description__ire: Option<Vec<String>>,
468    description__isw: Option<Vec<String>>,
469    description__n: Option<Vec<String>>,
470    description__nic: Option<Vec<String>>,
471    description__nie: Option<Vec<String>>,
472    description__niew: Option<Vec<String>>,
473    description__nire: Option<Vec<String>>,
474    description__nisw: Option<Vec<String>>,
475    description__nre: Option<Vec<String>>,
476    description__re: Option<Vec<String>>,
477    dynamic_groups: Option<Vec<String>>,
478    dynamic_groups__n: Option<Vec<String>>,
479    format: Option<&str>,
480    has_children: Option<bool>,
481    has_tenants: Option<bool>,
482    id: Option<Vec<uuid::Uuid>>,
483    id__n: Option<Vec<uuid::Uuid>>,
484    last_updated: Option<Vec<String>>,
485    last_updated__gt: Option<Vec<String>>,
486    last_updated__gte: Option<Vec<String>>,
487    last_updated__isnull: Option<bool>,
488    last_updated__lt: Option<Vec<String>>,
489    last_updated__lte: Option<Vec<String>>,
490    last_updated__n: Option<Vec<String>>,
491    limit: Option<i32>,
492    name: Option<Vec<String>>,
493    name__ic: Option<Vec<String>>,
494    name__ie: Option<Vec<String>>,
495    name__iew: Option<Vec<String>>,
496    name__ire: Option<Vec<String>>,
497    name__isw: Option<Vec<String>>,
498    name__n: Option<Vec<String>>,
499    name__nic: Option<Vec<String>>,
500    name__nie: Option<Vec<String>>,
501    name__niew: Option<Vec<String>>,
502    name__nire: Option<Vec<String>>,
503    name__nisw: Option<Vec<String>>,
504    name__nre: Option<Vec<String>>,
505    name__re: Option<Vec<String>>,
506    offset: Option<i32>,
507    parent: Option<Vec<String>>,
508    parent__isnull: Option<bool>,
509    parent__n: Option<Vec<String>>,
510    q: Option<&str>,
511    sort: Option<&str>,
512    teams: Option<Vec<String>>,
513    teams__isnull: Option<bool>,
514    teams__n: Option<Vec<String>>,
515    tenants: Option<Vec<String>>,
516    tenants__isnull: Option<bool>,
517    tenants__n: Option<Vec<String>>,
518    depth: Option<i32>,
519    exclude_m2m: Option<bool>,
520) -> Result<crate::models::PaginatedTenantGroupList, Error<TenancyTenantGroupsListError>> {
521    let local_var_configuration = configuration;
522
523    let local_var_client = &local_var_configuration.client;
524
525    let local_var_uri_str = format!(
526        "{}/tenancy/tenant-groups/",
527        local_var_configuration.base_path
528    );
529    let mut local_var_req_builder =
530        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
531
532    if let Some(ref local_var_str) = children {
533        local_var_req_builder = match "multi" {
534            "multi" => local_var_req_builder.query(
535                &local_var_str
536                    .into_iter()
537                    .map(|p| ("children".to_owned(), p.to_string()))
538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
539            ),
540            _ => local_var_req_builder.query(&[(
541                "children",
542                &local_var_str
543                    .into_iter()
544                    .map(|p| p.to_string())
545                    .collect::<Vec<String>>()
546                    .join(",")
547                    .to_string(),
548            )]),
549        };
550    }
551    if let Some(ref local_var_str) = children__isnull {
552        local_var_req_builder =
553            local_var_req_builder.query(&[("children__isnull", &local_var_str.to_string())]);
554    }
555    if let Some(ref local_var_str) = children__n {
556        local_var_req_builder = match "multi" {
557            "multi" => local_var_req_builder.query(
558                &local_var_str
559                    .into_iter()
560                    .map(|p| ("children__n".to_owned(), p.to_string()))
561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
562            ),
563            _ => local_var_req_builder.query(&[(
564                "children__n",
565                &local_var_str
566                    .into_iter()
567                    .map(|p| p.to_string())
568                    .collect::<Vec<String>>()
569                    .join(",")
570                    .to_string(),
571            )]),
572        };
573    }
574    if let Some(ref local_var_str) = contacts {
575        local_var_req_builder = match "multi" {
576            "multi" => local_var_req_builder.query(
577                &local_var_str
578                    .into_iter()
579                    .map(|p| ("contacts".to_owned(), p.to_string()))
580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
581            ),
582            _ => local_var_req_builder.query(&[(
583                "contacts",
584                &local_var_str
585                    .into_iter()
586                    .map(|p| p.to_string())
587                    .collect::<Vec<String>>()
588                    .join(",")
589                    .to_string(),
590            )]),
591        };
592    }
593    if let Some(ref local_var_str) = contacts__isnull {
594        local_var_req_builder =
595            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
596    }
597    if let Some(ref local_var_str) = contacts__n {
598        local_var_req_builder = match "multi" {
599            "multi" => local_var_req_builder.query(
600                &local_var_str
601                    .into_iter()
602                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
604            ),
605            _ => local_var_req_builder.query(&[(
606                "contacts__n",
607                &local_var_str
608                    .into_iter()
609                    .map(|p| p.to_string())
610                    .collect::<Vec<String>>()
611                    .join(",")
612                    .to_string(),
613            )]),
614        };
615    }
616    if let Some(ref local_var_str) = created {
617        local_var_req_builder = match "multi" {
618            "multi" => local_var_req_builder.query(
619                &local_var_str
620                    .into_iter()
621                    .map(|p| ("created".to_owned(), p.to_string()))
622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
623            ),
624            _ => local_var_req_builder.query(&[(
625                "created",
626                &local_var_str
627                    .into_iter()
628                    .map(|p| p.to_string())
629                    .collect::<Vec<String>>()
630                    .join(",")
631                    .to_string(),
632            )]),
633        };
634    }
635    if let Some(ref local_var_str) = created__gt {
636        local_var_req_builder = match "multi" {
637            "multi" => local_var_req_builder.query(
638                &local_var_str
639                    .into_iter()
640                    .map(|p| ("created__gt".to_owned(), p.to_string()))
641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
642            ),
643            _ => local_var_req_builder.query(&[(
644                "created__gt",
645                &local_var_str
646                    .into_iter()
647                    .map(|p| p.to_string())
648                    .collect::<Vec<String>>()
649                    .join(",")
650                    .to_string(),
651            )]),
652        };
653    }
654    if let Some(ref local_var_str) = created__gte {
655        local_var_req_builder = match "multi" {
656            "multi" => local_var_req_builder.query(
657                &local_var_str
658                    .into_iter()
659                    .map(|p| ("created__gte".to_owned(), p.to_string()))
660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
661            ),
662            _ => local_var_req_builder.query(&[(
663                "created__gte",
664                &local_var_str
665                    .into_iter()
666                    .map(|p| p.to_string())
667                    .collect::<Vec<String>>()
668                    .join(",")
669                    .to_string(),
670            )]),
671        };
672    }
673    if let Some(ref local_var_str) = created__isnull {
674        local_var_req_builder =
675            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
676    }
677    if let Some(ref local_var_str) = created__lt {
678        local_var_req_builder = match "multi" {
679            "multi" => local_var_req_builder.query(
680                &local_var_str
681                    .into_iter()
682                    .map(|p| ("created__lt".to_owned(), p.to_string()))
683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
684            ),
685            _ => local_var_req_builder.query(&[(
686                "created__lt",
687                &local_var_str
688                    .into_iter()
689                    .map(|p| p.to_string())
690                    .collect::<Vec<String>>()
691                    .join(",")
692                    .to_string(),
693            )]),
694        };
695    }
696    if let Some(ref local_var_str) = created__lte {
697        local_var_req_builder = match "multi" {
698            "multi" => local_var_req_builder.query(
699                &local_var_str
700                    .into_iter()
701                    .map(|p| ("created__lte".to_owned(), p.to_string()))
702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
703            ),
704            _ => local_var_req_builder.query(&[(
705                "created__lte",
706                &local_var_str
707                    .into_iter()
708                    .map(|p| p.to_string())
709                    .collect::<Vec<String>>()
710                    .join(",")
711                    .to_string(),
712            )]),
713        };
714    }
715    if let Some(ref local_var_str) = created__n {
716        local_var_req_builder = match "multi" {
717            "multi" => local_var_req_builder.query(
718                &local_var_str
719                    .into_iter()
720                    .map(|p| ("created__n".to_owned(), p.to_string()))
721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
722            ),
723            _ => local_var_req_builder.query(&[(
724                "created__n",
725                &local_var_str
726                    .into_iter()
727                    .map(|p| p.to_string())
728                    .collect::<Vec<String>>()
729                    .join(",")
730                    .to_string(),
731            )]),
732        };
733    }
734    if let Some(ref local_var_str) = description {
735        local_var_req_builder = match "multi" {
736            "multi" => local_var_req_builder.query(
737                &local_var_str
738                    .into_iter()
739                    .map(|p| ("description".to_owned(), p.to_string()))
740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
741            ),
742            _ => local_var_req_builder.query(&[(
743                "description",
744                &local_var_str
745                    .into_iter()
746                    .map(|p| p.to_string())
747                    .collect::<Vec<String>>()
748                    .join(",")
749                    .to_string(),
750            )]),
751        };
752    }
753    if let Some(ref local_var_str) = description__ic {
754        local_var_req_builder = match "multi" {
755            "multi" => local_var_req_builder.query(
756                &local_var_str
757                    .into_iter()
758                    .map(|p| ("description__ic".to_owned(), p.to_string()))
759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
760            ),
761            _ => local_var_req_builder.query(&[(
762                "description__ic",
763                &local_var_str
764                    .into_iter()
765                    .map(|p| p.to_string())
766                    .collect::<Vec<String>>()
767                    .join(",")
768                    .to_string(),
769            )]),
770        };
771    }
772    if let Some(ref local_var_str) = description__ie {
773        local_var_req_builder = match "multi" {
774            "multi" => local_var_req_builder.query(
775                &local_var_str
776                    .into_iter()
777                    .map(|p| ("description__ie".to_owned(), p.to_string()))
778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
779            ),
780            _ => local_var_req_builder.query(&[(
781                "description__ie",
782                &local_var_str
783                    .into_iter()
784                    .map(|p| p.to_string())
785                    .collect::<Vec<String>>()
786                    .join(",")
787                    .to_string(),
788            )]),
789        };
790    }
791    if let Some(ref local_var_str) = description__iew {
792        local_var_req_builder = match "multi" {
793            "multi" => local_var_req_builder.query(
794                &local_var_str
795                    .into_iter()
796                    .map(|p| ("description__iew".to_owned(), p.to_string()))
797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
798            ),
799            _ => local_var_req_builder.query(&[(
800                "description__iew",
801                &local_var_str
802                    .into_iter()
803                    .map(|p| p.to_string())
804                    .collect::<Vec<String>>()
805                    .join(",")
806                    .to_string(),
807            )]),
808        };
809    }
810    if let Some(ref local_var_str) = description__ire {
811        local_var_req_builder = match "multi" {
812            "multi" => local_var_req_builder.query(
813                &local_var_str
814                    .into_iter()
815                    .map(|p| ("description__ire".to_owned(), p.to_string()))
816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
817            ),
818            _ => local_var_req_builder.query(&[(
819                "description__ire",
820                &local_var_str
821                    .into_iter()
822                    .map(|p| p.to_string())
823                    .collect::<Vec<String>>()
824                    .join(",")
825                    .to_string(),
826            )]),
827        };
828    }
829    if let Some(ref local_var_str) = description__isw {
830        local_var_req_builder = match "multi" {
831            "multi" => local_var_req_builder.query(
832                &local_var_str
833                    .into_iter()
834                    .map(|p| ("description__isw".to_owned(), p.to_string()))
835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
836            ),
837            _ => local_var_req_builder.query(&[(
838                "description__isw",
839                &local_var_str
840                    .into_iter()
841                    .map(|p| p.to_string())
842                    .collect::<Vec<String>>()
843                    .join(",")
844                    .to_string(),
845            )]),
846        };
847    }
848    if let Some(ref local_var_str) = description__n {
849        local_var_req_builder = match "multi" {
850            "multi" => local_var_req_builder.query(
851                &local_var_str
852                    .into_iter()
853                    .map(|p| ("description__n".to_owned(), p.to_string()))
854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
855            ),
856            _ => local_var_req_builder.query(&[(
857                "description__n",
858                &local_var_str
859                    .into_iter()
860                    .map(|p| p.to_string())
861                    .collect::<Vec<String>>()
862                    .join(",")
863                    .to_string(),
864            )]),
865        };
866    }
867    if let Some(ref local_var_str) = description__nic {
868        local_var_req_builder = match "multi" {
869            "multi" => local_var_req_builder.query(
870                &local_var_str
871                    .into_iter()
872                    .map(|p| ("description__nic".to_owned(), p.to_string()))
873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
874            ),
875            _ => local_var_req_builder.query(&[(
876                "description__nic",
877                &local_var_str
878                    .into_iter()
879                    .map(|p| p.to_string())
880                    .collect::<Vec<String>>()
881                    .join(",")
882                    .to_string(),
883            )]),
884        };
885    }
886    if let Some(ref local_var_str) = description__nie {
887        local_var_req_builder = match "multi" {
888            "multi" => local_var_req_builder.query(
889                &local_var_str
890                    .into_iter()
891                    .map(|p| ("description__nie".to_owned(), p.to_string()))
892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
893            ),
894            _ => local_var_req_builder.query(&[(
895                "description__nie",
896                &local_var_str
897                    .into_iter()
898                    .map(|p| p.to_string())
899                    .collect::<Vec<String>>()
900                    .join(",")
901                    .to_string(),
902            )]),
903        };
904    }
905    if let Some(ref local_var_str) = description__niew {
906        local_var_req_builder = match "multi" {
907            "multi" => local_var_req_builder.query(
908                &local_var_str
909                    .into_iter()
910                    .map(|p| ("description__niew".to_owned(), p.to_string()))
911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
912            ),
913            _ => local_var_req_builder.query(&[(
914                "description__niew",
915                &local_var_str
916                    .into_iter()
917                    .map(|p| p.to_string())
918                    .collect::<Vec<String>>()
919                    .join(",")
920                    .to_string(),
921            )]),
922        };
923    }
924    if let Some(ref local_var_str) = description__nire {
925        local_var_req_builder = match "multi" {
926            "multi" => local_var_req_builder.query(
927                &local_var_str
928                    .into_iter()
929                    .map(|p| ("description__nire".to_owned(), p.to_string()))
930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
931            ),
932            _ => local_var_req_builder.query(&[(
933                "description__nire",
934                &local_var_str
935                    .into_iter()
936                    .map(|p| p.to_string())
937                    .collect::<Vec<String>>()
938                    .join(",")
939                    .to_string(),
940            )]),
941        };
942    }
943    if let Some(ref local_var_str) = description__nisw {
944        local_var_req_builder = match "multi" {
945            "multi" => local_var_req_builder.query(
946                &local_var_str
947                    .into_iter()
948                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
950            ),
951            _ => local_var_req_builder.query(&[(
952                "description__nisw",
953                &local_var_str
954                    .into_iter()
955                    .map(|p| p.to_string())
956                    .collect::<Vec<String>>()
957                    .join(",")
958                    .to_string(),
959            )]),
960        };
961    }
962    if let Some(ref local_var_str) = description__nre {
963        local_var_req_builder = match "multi" {
964            "multi" => local_var_req_builder.query(
965                &local_var_str
966                    .into_iter()
967                    .map(|p| ("description__nre".to_owned(), p.to_string()))
968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
969            ),
970            _ => local_var_req_builder.query(&[(
971                "description__nre",
972                &local_var_str
973                    .into_iter()
974                    .map(|p| p.to_string())
975                    .collect::<Vec<String>>()
976                    .join(",")
977                    .to_string(),
978            )]),
979        };
980    }
981    if let Some(ref local_var_str) = description__re {
982        local_var_req_builder = match "multi" {
983            "multi" => local_var_req_builder.query(
984                &local_var_str
985                    .into_iter()
986                    .map(|p| ("description__re".to_owned(), p.to_string()))
987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
988            ),
989            _ => local_var_req_builder.query(&[(
990                "description__re",
991                &local_var_str
992                    .into_iter()
993                    .map(|p| p.to_string())
994                    .collect::<Vec<String>>()
995                    .join(",")
996                    .to_string(),
997            )]),
998        };
999    }
1000    if let Some(ref local_var_str) = dynamic_groups {
1001        local_var_req_builder = match "multi" {
1002            "multi" => local_var_req_builder.query(
1003                &local_var_str
1004                    .into_iter()
1005                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
1006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1007            ),
1008            _ => local_var_req_builder.query(&[(
1009                "dynamic_groups",
1010                &local_var_str
1011                    .into_iter()
1012                    .map(|p| p.to_string())
1013                    .collect::<Vec<String>>()
1014                    .join(",")
1015                    .to_string(),
1016            )]),
1017        };
1018    }
1019    if let Some(ref local_var_str) = dynamic_groups__n {
1020        local_var_req_builder = match "multi" {
1021            "multi" => local_var_req_builder.query(
1022                &local_var_str
1023                    .into_iter()
1024                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
1025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1026            ),
1027            _ => local_var_req_builder.query(&[(
1028                "dynamic_groups__n",
1029                &local_var_str
1030                    .into_iter()
1031                    .map(|p| p.to_string())
1032                    .collect::<Vec<String>>()
1033                    .join(",")
1034                    .to_string(),
1035            )]),
1036        };
1037    }
1038    if let Some(ref local_var_str) = format {
1039        local_var_req_builder =
1040            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1041    }
1042    if let Some(ref local_var_str) = has_children {
1043        local_var_req_builder =
1044            local_var_req_builder.query(&[("has_children", &local_var_str.to_string())]);
1045    }
1046    if let Some(ref local_var_str) = has_tenants {
1047        local_var_req_builder =
1048            local_var_req_builder.query(&[("has_tenants", &local_var_str.to_string())]);
1049    }
1050    if let Some(ref local_var_str) = id {
1051        local_var_req_builder = match "multi" {
1052            "multi" => local_var_req_builder.query(
1053                &local_var_str
1054                    .into_iter()
1055                    .map(|p| ("id".to_owned(), p.to_string()))
1056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1057            ),
1058            _ => local_var_req_builder.query(&[(
1059                "id",
1060                &local_var_str
1061                    .into_iter()
1062                    .map(|p| p.to_string())
1063                    .collect::<Vec<String>>()
1064                    .join(",")
1065                    .to_string(),
1066            )]),
1067        };
1068    }
1069    if let Some(ref local_var_str) = id__n {
1070        local_var_req_builder = match "multi" {
1071            "multi" => local_var_req_builder.query(
1072                &local_var_str
1073                    .into_iter()
1074                    .map(|p| ("id__n".to_owned(), p.to_string()))
1075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1076            ),
1077            _ => local_var_req_builder.query(&[(
1078                "id__n",
1079                &local_var_str
1080                    .into_iter()
1081                    .map(|p| p.to_string())
1082                    .collect::<Vec<String>>()
1083                    .join(",")
1084                    .to_string(),
1085            )]),
1086        };
1087    }
1088    if let Some(ref local_var_str) = last_updated {
1089        local_var_req_builder = match "multi" {
1090            "multi" => local_var_req_builder.query(
1091                &local_var_str
1092                    .into_iter()
1093                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1095            ),
1096            _ => local_var_req_builder.query(&[(
1097                "last_updated",
1098                &local_var_str
1099                    .into_iter()
1100                    .map(|p| p.to_string())
1101                    .collect::<Vec<String>>()
1102                    .join(",")
1103                    .to_string(),
1104            )]),
1105        };
1106    }
1107    if let Some(ref local_var_str) = last_updated__gt {
1108        local_var_req_builder = match "multi" {
1109            "multi" => local_var_req_builder.query(
1110                &local_var_str
1111                    .into_iter()
1112                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1114            ),
1115            _ => local_var_req_builder.query(&[(
1116                "last_updated__gt",
1117                &local_var_str
1118                    .into_iter()
1119                    .map(|p| p.to_string())
1120                    .collect::<Vec<String>>()
1121                    .join(",")
1122                    .to_string(),
1123            )]),
1124        };
1125    }
1126    if let Some(ref local_var_str) = last_updated__gte {
1127        local_var_req_builder = match "multi" {
1128            "multi" => local_var_req_builder.query(
1129                &local_var_str
1130                    .into_iter()
1131                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1133            ),
1134            _ => local_var_req_builder.query(&[(
1135                "last_updated__gte",
1136                &local_var_str
1137                    .into_iter()
1138                    .map(|p| p.to_string())
1139                    .collect::<Vec<String>>()
1140                    .join(",")
1141                    .to_string(),
1142            )]),
1143        };
1144    }
1145    if let Some(ref local_var_str) = last_updated__isnull {
1146        local_var_req_builder =
1147            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
1148    }
1149    if let Some(ref local_var_str) = last_updated__lt {
1150        local_var_req_builder = match "multi" {
1151            "multi" => local_var_req_builder.query(
1152                &local_var_str
1153                    .into_iter()
1154                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1156            ),
1157            _ => local_var_req_builder.query(&[(
1158                "last_updated__lt",
1159                &local_var_str
1160                    .into_iter()
1161                    .map(|p| p.to_string())
1162                    .collect::<Vec<String>>()
1163                    .join(",")
1164                    .to_string(),
1165            )]),
1166        };
1167    }
1168    if let Some(ref local_var_str) = last_updated__lte {
1169        local_var_req_builder = match "multi" {
1170            "multi" => local_var_req_builder.query(
1171                &local_var_str
1172                    .into_iter()
1173                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1175            ),
1176            _ => local_var_req_builder.query(&[(
1177                "last_updated__lte",
1178                &local_var_str
1179                    .into_iter()
1180                    .map(|p| p.to_string())
1181                    .collect::<Vec<String>>()
1182                    .join(",")
1183                    .to_string(),
1184            )]),
1185        };
1186    }
1187    if let Some(ref local_var_str) = last_updated__n {
1188        local_var_req_builder = match "multi" {
1189            "multi" => local_var_req_builder.query(
1190                &local_var_str
1191                    .into_iter()
1192                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1194            ),
1195            _ => local_var_req_builder.query(&[(
1196                "last_updated__n",
1197                &local_var_str
1198                    .into_iter()
1199                    .map(|p| p.to_string())
1200                    .collect::<Vec<String>>()
1201                    .join(",")
1202                    .to_string(),
1203            )]),
1204        };
1205    }
1206    if let Some(ref local_var_str) = limit {
1207        local_var_req_builder =
1208            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1209    }
1210    if let Some(ref local_var_str) = name {
1211        local_var_req_builder = match "multi" {
1212            "multi" => local_var_req_builder.query(
1213                &local_var_str
1214                    .into_iter()
1215                    .map(|p| ("name".to_owned(), p.to_string()))
1216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1217            ),
1218            _ => local_var_req_builder.query(&[(
1219                "name",
1220                &local_var_str
1221                    .into_iter()
1222                    .map(|p| p.to_string())
1223                    .collect::<Vec<String>>()
1224                    .join(",")
1225                    .to_string(),
1226            )]),
1227        };
1228    }
1229    if let Some(ref local_var_str) = name__ic {
1230        local_var_req_builder = match "multi" {
1231            "multi" => local_var_req_builder.query(
1232                &local_var_str
1233                    .into_iter()
1234                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1236            ),
1237            _ => local_var_req_builder.query(&[(
1238                "name__ic",
1239                &local_var_str
1240                    .into_iter()
1241                    .map(|p| p.to_string())
1242                    .collect::<Vec<String>>()
1243                    .join(",")
1244                    .to_string(),
1245            )]),
1246        };
1247    }
1248    if let Some(ref local_var_str) = name__ie {
1249        local_var_req_builder = match "multi" {
1250            "multi" => local_var_req_builder.query(
1251                &local_var_str
1252                    .into_iter()
1253                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1255            ),
1256            _ => local_var_req_builder.query(&[(
1257                "name__ie",
1258                &local_var_str
1259                    .into_iter()
1260                    .map(|p| p.to_string())
1261                    .collect::<Vec<String>>()
1262                    .join(",")
1263                    .to_string(),
1264            )]),
1265        };
1266    }
1267    if let Some(ref local_var_str) = name__iew {
1268        local_var_req_builder = match "multi" {
1269            "multi" => local_var_req_builder.query(
1270                &local_var_str
1271                    .into_iter()
1272                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1274            ),
1275            _ => local_var_req_builder.query(&[(
1276                "name__iew",
1277                &local_var_str
1278                    .into_iter()
1279                    .map(|p| p.to_string())
1280                    .collect::<Vec<String>>()
1281                    .join(",")
1282                    .to_string(),
1283            )]),
1284        };
1285    }
1286    if let Some(ref local_var_str) = name__ire {
1287        local_var_req_builder = match "multi" {
1288            "multi" => local_var_req_builder.query(
1289                &local_var_str
1290                    .into_iter()
1291                    .map(|p| ("name__ire".to_owned(), p.to_string()))
1292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1293            ),
1294            _ => local_var_req_builder.query(&[(
1295                "name__ire",
1296                &local_var_str
1297                    .into_iter()
1298                    .map(|p| p.to_string())
1299                    .collect::<Vec<String>>()
1300                    .join(",")
1301                    .to_string(),
1302            )]),
1303        };
1304    }
1305    if let Some(ref local_var_str) = name__isw {
1306        local_var_req_builder = match "multi" {
1307            "multi" => local_var_req_builder.query(
1308                &local_var_str
1309                    .into_iter()
1310                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1312            ),
1313            _ => local_var_req_builder.query(&[(
1314                "name__isw",
1315                &local_var_str
1316                    .into_iter()
1317                    .map(|p| p.to_string())
1318                    .collect::<Vec<String>>()
1319                    .join(",")
1320                    .to_string(),
1321            )]),
1322        };
1323    }
1324    if let Some(ref local_var_str) = name__n {
1325        local_var_req_builder = match "multi" {
1326            "multi" => local_var_req_builder.query(
1327                &local_var_str
1328                    .into_iter()
1329                    .map(|p| ("name__n".to_owned(), p.to_string()))
1330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1331            ),
1332            _ => local_var_req_builder.query(&[(
1333                "name__n",
1334                &local_var_str
1335                    .into_iter()
1336                    .map(|p| p.to_string())
1337                    .collect::<Vec<String>>()
1338                    .join(",")
1339                    .to_string(),
1340            )]),
1341        };
1342    }
1343    if let Some(ref local_var_str) = name__nic {
1344        local_var_req_builder = match "multi" {
1345            "multi" => local_var_req_builder.query(
1346                &local_var_str
1347                    .into_iter()
1348                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1350            ),
1351            _ => local_var_req_builder.query(&[(
1352                "name__nic",
1353                &local_var_str
1354                    .into_iter()
1355                    .map(|p| p.to_string())
1356                    .collect::<Vec<String>>()
1357                    .join(",")
1358                    .to_string(),
1359            )]),
1360        };
1361    }
1362    if let Some(ref local_var_str) = name__nie {
1363        local_var_req_builder = match "multi" {
1364            "multi" => local_var_req_builder.query(
1365                &local_var_str
1366                    .into_iter()
1367                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1369            ),
1370            _ => local_var_req_builder.query(&[(
1371                "name__nie",
1372                &local_var_str
1373                    .into_iter()
1374                    .map(|p| p.to_string())
1375                    .collect::<Vec<String>>()
1376                    .join(",")
1377                    .to_string(),
1378            )]),
1379        };
1380    }
1381    if let Some(ref local_var_str) = name__niew {
1382        local_var_req_builder = match "multi" {
1383            "multi" => local_var_req_builder.query(
1384                &local_var_str
1385                    .into_iter()
1386                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1388            ),
1389            _ => local_var_req_builder.query(&[(
1390                "name__niew",
1391                &local_var_str
1392                    .into_iter()
1393                    .map(|p| p.to_string())
1394                    .collect::<Vec<String>>()
1395                    .join(",")
1396                    .to_string(),
1397            )]),
1398        };
1399    }
1400    if let Some(ref local_var_str) = name__nire {
1401        local_var_req_builder = match "multi" {
1402            "multi" => local_var_req_builder.query(
1403                &local_var_str
1404                    .into_iter()
1405                    .map(|p| ("name__nire".to_owned(), p.to_string()))
1406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1407            ),
1408            _ => local_var_req_builder.query(&[(
1409                "name__nire",
1410                &local_var_str
1411                    .into_iter()
1412                    .map(|p| p.to_string())
1413                    .collect::<Vec<String>>()
1414                    .join(",")
1415                    .to_string(),
1416            )]),
1417        };
1418    }
1419    if let Some(ref local_var_str) = name__nisw {
1420        local_var_req_builder = match "multi" {
1421            "multi" => local_var_req_builder.query(
1422                &local_var_str
1423                    .into_iter()
1424                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1426            ),
1427            _ => local_var_req_builder.query(&[(
1428                "name__nisw",
1429                &local_var_str
1430                    .into_iter()
1431                    .map(|p| p.to_string())
1432                    .collect::<Vec<String>>()
1433                    .join(",")
1434                    .to_string(),
1435            )]),
1436        };
1437    }
1438    if let Some(ref local_var_str) = name__nre {
1439        local_var_req_builder = match "multi" {
1440            "multi" => local_var_req_builder.query(
1441                &local_var_str
1442                    .into_iter()
1443                    .map(|p| ("name__nre".to_owned(), p.to_string()))
1444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1445            ),
1446            _ => local_var_req_builder.query(&[(
1447                "name__nre",
1448                &local_var_str
1449                    .into_iter()
1450                    .map(|p| p.to_string())
1451                    .collect::<Vec<String>>()
1452                    .join(",")
1453                    .to_string(),
1454            )]),
1455        };
1456    }
1457    if let Some(ref local_var_str) = name__re {
1458        local_var_req_builder = match "multi" {
1459            "multi" => local_var_req_builder.query(
1460                &local_var_str
1461                    .into_iter()
1462                    .map(|p| ("name__re".to_owned(), p.to_string()))
1463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1464            ),
1465            _ => local_var_req_builder.query(&[(
1466                "name__re",
1467                &local_var_str
1468                    .into_iter()
1469                    .map(|p| p.to_string())
1470                    .collect::<Vec<String>>()
1471                    .join(",")
1472                    .to_string(),
1473            )]),
1474        };
1475    }
1476    if let Some(ref local_var_str) = offset {
1477        local_var_req_builder =
1478            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1479    }
1480    if let Some(ref local_var_str) = parent {
1481        local_var_req_builder = match "multi" {
1482            "multi" => local_var_req_builder.query(
1483                &local_var_str
1484                    .into_iter()
1485                    .map(|p| ("parent".to_owned(), p.to_string()))
1486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1487            ),
1488            _ => local_var_req_builder.query(&[(
1489                "parent",
1490                &local_var_str
1491                    .into_iter()
1492                    .map(|p| p.to_string())
1493                    .collect::<Vec<String>>()
1494                    .join(",")
1495                    .to_string(),
1496            )]),
1497        };
1498    }
1499    if let Some(ref local_var_str) = parent__isnull {
1500        local_var_req_builder =
1501            local_var_req_builder.query(&[("parent__isnull", &local_var_str.to_string())]);
1502    }
1503    if let Some(ref local_var_str) = parent__n {
1504        local_var_req_builder = match "multi" {
1505            "multi" => local_var_req_builder.query(
1506                &local_var_str
1507                    .into_iter()
1508                    .map(|p| ("parent__n".to_owned(), p.to_string()))
1509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1510            ),
1511            _ => local_var_req_builder.query(&[(
1512                "parent__n",
1513                &local_var_str
1514                    .into_iter()
1515                    .map(|p| p.to_string())
1516                    .collect::<Vec<String>>()
1517                    .join(",")
1518                    .to_string(),
1519            )]),
1520        };
1521    }
1522    if let Some(ref local_var_str) = q {
1523        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1524    }
1525    if let Some(ref local_var_str) = sort {
1526        local_var_req_builder =
1527            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
1528    }
1529    if let Some(ref local_var_str) = teams {
1530        local_var_req_builder = match "multi" {
1531            "multi" => local_var_req_builder.query(
1532                &local_var_str
1533                    .into_iter()
1534                    .map(|p| ("teams".to_owned(), p.to_string()))
1535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1536            ),
1537            _ => local_var_req_builder.query(&[(
1538                "teams",
1539                &local_var_str
1540                    .into_iter()
1541                    .map(|p| p.to_string())
1542                    .collect::<Vec<String>>()
1543                    .join(",")
1544                    .to_string(),
1545            )]),
1546        };
1547    }
1548    if let Some(ref local_var_str) = teams__isnull {
1549        local_var_req_builder =
1550            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
1551    }
1552    if let Some(ref local_var_str) = teams__n {
1553        local_var_req_builder = match "multi" {
1554            "multi" => local_var_req_builder.query(
1555                &local_var_str
1556                    .into_iter()
1557                    .map(|p| ("teams__n".to_owned(), p.to_string()))
1558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1559            ),
1560            _ => local_var_req_builder.query(&[(
1561                "teams__n",
1562                &local_var_str
1563                    .into_iter()
1564                    .map(|p| p.to_string())
1565                    .collect::<Vec<String>>()
1566                    .join(",")
1567                    .to_string(),
1568            )]),
1569        };
1570    }
1571    if let Some(ref local_var_str) = tenants {
1572        local_var_req_builder = match "multi" {
1573            "multi" => local_var_req_builder.query(
1574                &local_var_str
1575                    .into_iter()
1576                    .map(|p| ("tenants".to_owned(), p.to_string()))
1577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1578            ),
1579            _ => local_var_req_builder.query(&[(
1580                "tenants",
1581                &local_var_str
1582                    .into_iter()
1583                    .map(|p| p.to_string())
1584                    .collect::<Vec<String>>()
1585                    .join(",")
1586                    .to_string(),
1587            )]),
1588        };
1589    }
1590    if let Some(ref local_var_str) = tenants__isnull {
1591        local_var_req_builder =
1592            local_var_req_builder.query(&[("tenants__isnull", &local_var_str.to_string())]);
1593    }
1594    if let Some(ref local_var_str) = tenants__n {
1595        local_var_req_builder = match "multi" {
1596            "multi" => local_var_req_builder.query(
1597                &local_var_str
1598                    .into_iter()
1599                    .map(|p| ("tenants__n".to_owned(), p.to_string()))
1600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1601            ),
1602            _ => local_var_req_builder.query(&[(
1603                "tenants__n",
1604                &local_var_str
1605                    .into_iter()
1606                    .map(|p| p.to_string())
1607                    .collect::<Vec<String>>()
1608                    .join(",")
1609                    .to_string(),
1610            )]),
1611        };
1612    }
1613    if let Some(ref local_var_str) = depth {
1614        local_var_req_builder =
1615            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1616    }
1617    if let Some(ref local_var_str) = exclude_m2m {
1618        local_var_req_builder =
1619            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1620    }
1621    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1622        local_var_req_builder =
1623            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1624    }
1625    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1626        let local_var_key = local_var_apikey.key.clone();
1627        let local_var_value = match local_var_apikey.prefix {
1628            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1629            None => local_var_key,
1630        };
1631        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1632    };
1633
1634    let local_var_req = local_var_req_builder.build()?;
1635    let local_var_resp = local_var_client.execute(local_var_req).await?;
1636
1637    let local_var_status = local_var_resp.status();
1638    let local_var_content = local_var_resp.text().await?;
1639
1640    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1641        serde_json::from_str(&local_var_content).map_err(Error::from)
1642    } else {
1643        let local_var_entity: Option<TenancyTenantGroupsListError> =
1644            serde_json::from_str(&local_var_content).ok();
1645        let local_var_error = ResponseContent {
1646            status: local_var_status,
1647            content: local_var_content,
1648            entity: local_var_entity,
1649        };
1650        Err(Error::ResponseError(local_var_error))
1651    }
1652}
1653
1654/// API methods for returning or creating notes on an object.
1655pub async fn tenancy_tenant_groups_notes_create(
1656    configuration: &configuration::Configuration,
1657    id: &str,
1658    note_input_request: crate::models::NoteInputRequest,
1659    format: Option<&str>,
1660) -> Result<crate::models::Note, Error<TenancyTenantGroupsNotesCreateError>> {
1661    let local_var_configuration = configuration;
1662
1663    let local_var_client = &local_var_configuration.client;
1664
1665    let local_var_uri_str = format!(
1666        "{}/tenancy/tenant-groups/{id}/notes/",
1667        local_var_configuration.base_path,
1668        id = crate::apis::urlencode(id)
1669    );
1670    let mut local_var_req_builder =
1671        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1672
1673    if let Some(ref local_var_str) = format {
1674        local_var_req_builder =
1675            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1676    }
1677    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1678        local_var_req_builder =
1679            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1680    }
1681    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1682        let local_var_key = local_var_apikey.key.clone();
1683        let local_var_value = match local_var_apikey.prefix {
1684            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1685            None => local_var_key,
1686        };
1687        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1688    };
1689    local_var_req_builder = local_var_req_builder.json(&note_input_request);
1690
1691    let local_var_req = local_var_req_builder.build()?;
1692    let local_var_resp = local_var_client.execute(local_var_req).await?;
1693
1694    let local_var_status = local_var_resp.status();
1695    let local_var_content = local_var_resp.text().await?;
1696
1697    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1698        serde_json::from_str(&local_var_content).map_err(Error::from)
1699    } else {
1700        let local_var_entity: Option<TenancyTenantGroupsNotesCreateError> =
1701            serde_json::from_str(&local_var_content).ok();
1702        let local_var_error = ResponseContent {
1703            status: local_var_status,
1704            content: local_var_content,
1705            entity: local_var_entity,
1706        };
1707        Err(Error::ResponseError(local_var_error))
1708    }
1709}
1710
1711/// API methods for returning or creating notes on an object.
1712pub async fn tenancy_tenant_groups_notes_list(
1713    configuration: &configuration::Configuration,
1714    id: &str,
1715    format: Option<&str>,
1716    limit: Option<i32>,
1717    offset: Option<i32>,
1718    depth: Option<i32>,
1719    exclude_m2m: Option<bool>,
1720) -> Result<crate::models::PaginatedNoteList, Error<TenancyTenantGroupsNotesListError>> {
1721    let local_var_configuration = configuration;
1722
1723    let local_var_client = &local_var_configuration.client;
1724
1725    let local_var_uri_str = format!(
1726        "{}/tenancy/tenant-groups/{id}/notes/",
1727        local_var_configuration.base_path,
1728        id = crate::apis::urlencode(id)
1729    );
1730    let mut local_var_req_builder =
1731        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1732
1733    if let Some(ref local_var_str) = format {
1734        local_var_req_builder =
1735            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1736    }
1737    if let Some(ref local_var_str) = limit {
1738        local_var_req_builder =
1739            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1740    }
1741    if let Some(ref local_var_str) = offset {
1742        local_var_req_builder =
1743            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1744    }
1745    if let Some(ref local_var_str) = depth {
1746        local_var_req_builder =
1747            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1748    }
1749    if let Some(ref local_var_str) = exclude_m2m {
1750        local_var_req_builder =
1751            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1752    }
1753    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1754        local_var_req_builder =
1755            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1756    }
1757    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1758        let local_var_key = local_var_apikey.key.clone();
1759        let local_var_value = match local_var_apikey.prefix {
1760            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1761            None => local_var_key,
1762        };
1763        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1764    };
1765
1766    let local_var_req = local_var_req_builder.build()?;
1767    let local_var_resp = local_var_client.execute(local_var_req).await?;
1768
1769    let local_var_status = local_var_resp.status();
1770    let local_var_content = local_var_resp.text().await?;
1771
1772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1773        serde_json::from_str(&local_var_content).map_err(Error::from)
1774    } else {
1775        let local_var_entity: Option<TenancyTenantGroupsNotesListError> =
1776            serde_json::from_str(&local_var_content).ok();
1777        let local_var_error = ResponseContent {
1778            status: local_var_status,
1779            content: local_var_content,
1780            entity: local_var_entity,
1781        };
1782        Err(Error::ResponseError(local_var_error))
1783    }
1784}
1785
1786/// Partial update a tenant group object.
1787pub async fn tenancy_tenant_groups_partial_update(
1788    configuration: &configuration::Configuration,
1789    id: &str,
1790    format: Option<&str>,
1791    patched_tenant_group_request: Option<crate::models::PatchedTenantGroupRequest>,
1792) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsPartialUpdateError>> {
1793    let local_var_configuration = configuration;
1794
1795    let local_var_client = &local_var_configuration.client;
1796
1797    let local_var_uri_str = format!(
1798        "{}/tenancy/tenant-groups/{id}/",
1799        local_var_configuration.base_path,
1800        id = crate::apis::urlencode(id)
1801    );
1802    let mut local_var_req_builder =
1803        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1804
1805    if let Some(ref local_var_str) = format {
1806        local_var_req_builder =
1807            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1808    }
1809    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1810        local_var_req_builder =
1811            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1812    }
1813    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1814        let local_var_key = local_var_apikey.key.clone();
1815        let local_var_value = match local_var_apikey.prefix {
1816            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1817            None => local_var_key,
1818        };
1819        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1820    };
1821    local_var_req_builder = local_var_req_builder.json(&patched_tenant_group_request);
1822
1823    let local_var_req = local_var_req_builder.build()?;
1824    let local_var_resp = local_var_client.execute(local_var_req).await?;
1825
1826    let local_var_status = local_var_resp.status();
1827    let local_var_content = local_var_resp.text().await?;
1828
1829    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1830        serde_json::from_str(&local_var_content).map_err(Error::from)
1831    } else {
1832        let local_var_entity: Option<TenancyTenantGroupsPartialUpdateError> =
1833            serde_json::from_str(&local_var_content).ok();
1834        let local_var_error = ResponseContent {
1835            status: local_var_status,
1836            content: local_var_content,
1837            entity: local_var_entity,
1838        };
1839        Err(Error::ResponseError(local_var_error))
1840    }
1841}
1842
1843/// Retrieve a tenant group object.
1844pub async fn tenancy_tenant_groups_retrieve(
1845    configuration: &configuration::Configuration,
1846    id: &str,
1847    format: Option<&str>,
1848    depth: Option<i32>,
1849    exclude_m2m: Option<bool>,
1850) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsRetrieveError>> {
1851    let local_var_configuration = configuration;
1852
1853    let local_var_client = &local_var_configuration.client;
1854
1855    let local_var_uri_str = format!(
1856        "{}/tenancy/tenant-groups/{id}/",
1857        local_var_configuration.base_path,
1858        id = crate::apis::urlencode(id)
1859    );
1860    let mut local_var_req_builder =
1861        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1862
1863    if let Some(ref local_var_str) = format {
1864        local_var_req_builder =
1865            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1866    }
1867    if let Some(ref local_var_str) = depth {
1868        local_var_req_builder =
1869            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1870    }
1871    if let Some(ref local_var_str) = exclude_m2m {
1872        local_var_req_builder =
1873            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1874    }
1875    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1876        local_var_req_builder =
1877            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1878    }
1879    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1880        let local_var_key = local_var_apikey.key.clone();
1881        let local_var_value = match local_var_apikey.prefix {
1882            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1883            None => local_var_key,
1884        };
1885        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1886    };
1887
1888    let local_var_req = local_var_req_builder.build()?;
1889    let local_var_resp = local_var_client.execute(local_var_req).await?;
1890
1891    let local_var_status = local_var_resp.status();
1892    let local_var_content = local_var_resp.text().await?;
1893
1894    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1895        serde_json::from_str(&local_var_content).map_err(Error::from)
1896    } else {
1897        let local_var_entity: Option<TenancyTenantGroupsRetrieveError> =
1898            serde_json::from_str(&local_var_content).ok();
1899        let local_var_error = ResponseContent {
1900            status: local_var_status,
1901            content: local_var_content,
1902            entity: local_var_entity,
1903        };
1904        Err(Error::ResponseError(local_var_error))
1905    }
1906}
1907
1908/// Update a tenant group object.
1909pub async fn tenancy_tenant_groups_update(
1910    configuration: &configuration::Configuration,
1911    id: &str,
1912    tenant_group_request: crate::models::TenantGroupRequest,
1913    format: Option<&str>,
1914) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsUpdateError>> {
1915    let local_var_configuration = configuration;
1916
1917    let local_var_client = &local_var_configuration.client;
1918
1919    let local_var_uri_str = format!(
1920        "{}/tenancy/tenant-groups/{id}/",
1921        local_var_configuration.base_path,
1922        id = crate::apis::urlencode(id)
1923    );
1924    let mut local_var_req_builder =
1925        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1926
1927    if let Some(ref local_var_str) = format {
1928        local_var_req_builder =
1929            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1930    }
1931    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1932        local_var_req_builder =
1933            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1934    }
1935    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1936        let local_var_key = local_var_apikey.key.clone();
1937        let local_var_value = match local_var_apikey.prefix {
1938            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1939            None => local_var_key,
1940        };
1941        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1942    };
1943    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
1944
1945    let local_var_req = local_var_req_builder.build()?;
1946    let local_var_resp = local_var_client.execute(local_var_req).await?;
1947
1948    let local_var_status = local_var_resp.status();
1949    let local_var_content = local_var_resp.text().await?;
1950
1951    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1952        serde_json::from_str(&local_var_content).map_err(Error::from)
1953    } else {
1954        let local_var_entity: Option<TenancyTenantGroupsUpdateError> =
1955            serde_json::from_str(&local_var_content).ok();
1956        let local_var_error = ResponseContent {
1957            status: local_var_status,
1958            content: local_var_content,
1959            entity: local_var_entity,
1960        };
1961        Err(Error::ResponseError(local_var_error))
1962    }
1963}
1964
1965/// Destroy a list of tenant objects.
1966pub async fn tenancy_tenants_bulk_destroy(
1967    configuration: &configuration::Configuration,
1968    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
1969    format: Option<&str>,
1970) -> Result<(), Error<TenancyTenantsBulkDestroyError>> {
1971    let local_var_configuration = configuration;
1972
1973    let local_var_client = &local_var_configuration.client;
1974
1975    let local_var_uri_str = format!("{}/tenancy/tenants/", local_var_configuration.base_path);
1976    let mut local_var_req_builder =
1977        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1978
1979    if let Some(ref local_var_str) = format {
1980        local_var_req_builder =
1981            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1982    }
1983    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1984        local_var_req_builder =
1985            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1986    }
1987    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1988        let local_var_key = local_var_apikey.key.clone();
1989        let local_var_value = match local_var_apikey.prefix {
1990            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1991            None => local_var_key,
1992        };
1993        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1994    };
1995    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
1996
1997    let local_var_req = local_var_req_builder.build()?;
1998    let local_var_resp = local_var_client.execute(local_var_req).await?;
1999
2000    let local_var_status = local_var_resp.status();
2001    let local_var_content = local_var_resp.text().await?;
2002
2003    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2004        Ok(())
2005    } else {
2006        let local_var_entity: Option<TenancyTenantsBulkDestroyError> =
2007            serde_json::from_str(&local_var_content).ok();
2008        let local_var_error = ResponseContent {
2009            status: local_var_status,
2010            content: local_var_content,
2011            entity: local_var_entity,
2012        };
2013        Err(Error::ResponseError(local_var_error))
2014    }
2015}
2016
2017/// Partial update a list of tenant objects.
2018pub async fn tenancy_tenants_bulk_partial_update(
2019    configuration: &configuration::Configuration,
2020    patched_bulk_writable_tenant_request: Vec<crate::models::PatchedBulkWritableTenantRequest>,
2021    format: Option<&str>,
2022) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkPartialUpdateError>> {
2023    let local_var_configuration = configuration;
2024
2025    let local_var_client = &local_var_configuration.client;
2026
2027    let local_var_uri_str = format!("{}/tenancy/tenants/", local_var_configuration.base_path);
2028    let mut local_var_req_builder =
2029        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2030
2031    if let Some(ref local_var_str) = format {
2032        local_var_req_builder =
2033            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2034    }
2035    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2036        local_var_req_builder =
2037            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2038    }
2039    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2040        let local_var_key = local_var_apikey.key.clone();
2041        let local_var_value = match local_var_apikey.prefix {
2042            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2043            None => local_var_key,
2044        };
2045        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2046    };
2047    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_tenant_request);
2048
2049    let local_var_req = local_var_req_builder.build()?;
2050    let local_var_resp = local_var_client.execute(local_var_req).await?;
2051
2052    let local_var_status = local_var_resp.status();
2053    let local_var_content = local_var_resp.text().await?;
2054
2055    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2056        serde_json::from_str(&local_var_content).map_err(Error::from)
2057    } else {
2058        let local_var_entity: Option<TenancyTenantsBulkPartialUpdateError> =
2059            serde_json::from_str(&local_var_content).ok();
2060        let local_var_error = ResponseContent {
2061            status: local_var_status,
2062            content: local_var_content,
2063            entity: local_var_entity,
2064        };
2065        Err(Error::ResponseError(local_var_error))
2066    }
2067}
2068
2069/// Update a list of tenant objects.
2070pub async fn tenancy_tenants_bulk_update(
2071    configuration: &configuration::Configuration,
2072    bulk_writable_tenant_request: Vec<crate::models::BulkWritableTenantRequest>,
2073    format: Option<&str>,
2074) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkUpdateError>> {
2075    let local_var_configuration = configuration;
2076
2077    let local_var_client = &local_var_configuration.client;
2078
2079    let local_var_uri_str = format!("{}/tenancy/tenants/", local_var_configuration.base_path);
2080    let mut local_var_req_builder =
2081        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2082
2083    if let Some(ref local_var_str) = format {
2084        local_var_req_builder =
2085            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2086    }
2087    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2088        local_var_req_builder =
2089            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2090    }
2091    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2092        let local_var_key = local_var_apikey.key.clone();
2093        let local_var_value = match local_var_apikey.prefix {
2094            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2095            None => local_var_key,
2096        };
2097        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2098    };
2099    local_var_req_builder = local_var_req_builder.json(&bulk_writable_tenant_request);
2100
2101    let local_var_req = local_var_req_builder.build()?;
2102    let local_var_resp = local_var_client.execute(local_var_req).await?;
2103
2104    let local_var_status = local_var_resp.status();
2105    let local_var_content = local_var_resp.text().await?;
2106
2107    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2108        serde_json::from_str(&local_var_content).map_err(Error::from)
2109    } else {
2110        let local_var_entity: Option<TenancyTenantsBulkUpdateError> =
2111            serde_json::from_str(&local_var_content).ok();
2112        let local_var_error = ResponseContent {
2113            status: local_var_status,
2114            content: local_var_content,
2115            entity: local_var_entity,
2116        };
2117        Err(Error::ResponseError(local_var_error))
2118    }
2119}
2120
2121/// Create one or more tenant objects.
2122pub async fn tenancy_tenants_create(
2123    configuration: &configuration::Configuration,
2124    tenant_request: crate::models::TenantRequest,
2125    format: Option<&str>,
2126) -> Result<crate::models::Tenant, Error<TenancyTenantsCreateError>> {
2127    let local_var_configuration = configuration;
2128
2129    let local_var_client = &local_var_configuration.client;
2130
2131    let local_var_uri_str = format!("{}/tenancy/tenants/", local_var_configuration.base_path);
2132    let mut local_var_req_builder =
2133        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2134
2135    if let Some(ref local_var_str) = format {
2136        local_var_req_builder =
2137            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2138    }
2139    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2140        local_var_req_builder =
2141            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2142    }
2143    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2144        let local_var_key = local_var_apikey.key.clone();
2145        let local_var_value = match local_var_apikey.prefix {
2146            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2147            None => local_var_key,
2148        };
2149        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2150    };
2151    local_var_req_builder = local_var_req_builder.json(&tenant_request);
2152
2153    let local_var_req = local_var_req_builder.build()?;
2154    let local_var_resp = local_var_client.execute(local_var_req).await?;
2155
2156    let local_var_status = local_var_resp.status();
2157    let local_var_content = local_var_resp.text().await?;
2158
2159    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2160        serde_json::from_str(&local_var_content).map_err(Error::from)
2161    } else {
2162        let local_var_entity: Option<TenancyTenantsCreateError> =
2163            serde_json::from_str(&local_var_content).ok();
2164        let local_var_error = ResponseContent {
2165            status: local_var_status,
2166            content: local_var_content,
2167            entity: local_var_entity,
2168        };
2169        Err(Error::ResponseError(local_var_error))
2170    }
2171}
2172
2173/// Destroy a tenant object.
2174pub async fn tenancy_tenants_destroy(
2175    configuration: &configuration::Configuration,
2176    id: &str,
2177    format: Option<&str>,
2178) -> Result<(), Error<TenancyTenantsDestroyError>> {
2179    let local_var_configuration = configuration;
2180
2181    let local_var_client = &local_var_configuration.client;
2182
2183    let local_var_uri_str = format!(
2184        "{}/tenancy/tenants/{id}/",
2185        local_var_configuration.base_path,
2186        id = crate::apis::urlencode(id)
2187    );
2188    let mut local_var_req_builder =
2189        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2190
2191    if let Some(ref local_var_str) = format {
2192        local_var_req_builder =
2193            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2194    }
2195    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2196        local_var_req_builder =
2197            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2198    }
2199    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2200        let local_var_key = local_var_apikey.key.clone();
2201        let local_var_value = match local_var_apikey.prefix {
2202            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2203            None => local_var_key,
2204        };
2205        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2206    };
2207
2208    let local_var_req = local_var_req_builder.build()?;
2209    let local_var_resp = local_var_client.execute(local_var_req).await?;
2210
2211    let local_var_status = local_var_resp.status();
2212    let local_var_content = local_var_resp.text().await?;
2213
2214    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2215        Ok(())
2216    } else {
2217        let local_var_entity: Option<TenancyTenantsDestroyError> =
2218            serde_json::from_str(&local_var_content).ok();
2219        let local_var_error = ResponseContent {
2220            status: local_var_status,
2221            content: local_var_content,
2222            entity: local_var_entity,
2223        };
2224        Err(Error::ResponseError(local_var_error))
2225    }
2226}
2227
2228/// Retrieve a list of tenant objects.
2229pub async fn tenancy_tenants_list(
2230    configuration: &configuration::Configuration,
2231    circuits: Option<Vec<uuid::Uuid>>,
2232    circuits__isnull: Option<bool>,
2233    circuits__n: Option<Vec<uuid::Uuid>>,
2234    clusters: Option<Vec<String>>,
2235    clusters__isnull: Option<bool>,
2236    clusters__n: Option<Vec<String>>,
2237    comments: Option<Vec<String>>,
2238    comments__ic: Option<Vec<String>>,
2239    comments__ie: Option<Vec<String>>,
2240    comments__iew: Option<Vec<String>>,
2241    comments__ire: Option<Vec<String>>,
2242    comments__isw: Option<Vec<String>>,
2243    comments__n: Option<Vec<String>>,
2244    comments__nic: Option<Vec<String>>,
2245    comments__nie: Option<Vec<String>>,
2246    comments__niew: Option<Vec<String>>,
2247    comments__nire: Option<Vec<String>>,
2248    comments__nisw: Option<Vec<String>>,
2249    comments__nre: Option<Vec<String>>,
2250    comments__re: Option<Vec<String>>,
2251    contacts: Option<Vec<String>>,
2252    contacts__isnull: Option<bool>,
2253    contacts__n: Option<Vec<String>>,
2254    created: Option<Vec<String>>,
2255    created__gt: Option<Vec<String>>,
2256    created__gte: Option<Vec<String>>,
2257    created__isnull: Option<bool>,
2258    created__lt: Option<Vec<String>>,
2259    created__lte: Option<Vec<String>>,
2260    created__n: Option<Vec<String>>,
2261    description: Option<Vec<String>>,
2262    description__ic: Option<Vec<String>>,
2263    description__ie: Option<Vec<String>>,
2264    description__iew: Option<Vec<String>>,
2265    description__ire: Option<Vec<String>>,
2266    description__isw: Option<Vec<String>>,
2267    description__n: Option<Vec<String>>,
2268    description__nic: Option<Vec<String>>,
2269    description__nie: Option<Vec<String>>,
2270    description__niew: Option<Vec<String>>,
2271    description__nire: Option<Vec<String>>,
2272    description__nisw: Option<Vec<String>>,
2273    description__nre: Option<Vec<String>>,
2274    description__re: Option<Vec<String>>,
2275    devices: Option<Vec<String>>,
2276    devices__isnull: Option<bool>,
2277    devices__n: Option<Vec<String>>,
2278    dynamic_groups: Option<Vec<String>>,
2279    dynamic_groups__n: Option<Vec<String>>,
2280    format: Option<&str>,
2281    has_circuits: Option<bool>,
2282    has_clusters: Option<bool>,
2283    has_devices: Option<bool>,
2284    has_ip_addresses: Option<bool>,
2285    has_locations: Option<bool>,
2286    has_prefixes: Option<bool>,
2287    has_rack_reservations: Option<bool>,
2288    has_racks: Option<bool>,
2289    has_route_targets: Option<bool>,
2290    has_virtual_machines: Option<bool>,
2291    has_vlans: Option<bool>,
2292    has_vrfs: Option<bool>,
2293    id: Option<Vec<uuid::Uuid>>,
2294    id__n: Option<Vec<uuid::Uuid>>,
2295    ip_addresses: Option<Vec<uuid::Uuid>>,
2296    ip_addresses__isnull: Option<bool>,
2297    ip_addresses__n: Option<Vec<uuid::Uuid>>,
2298    last_updated: Option<Vec<String>>,
2299    last_updated__gt: Option<Vec<String>>,
2300    last_updated__gte: Option<Vec<String>>,
2301    last_updated__isnull: Option<bool>,
2302    last_updated__lt: Option<Vec<String>>,
2303    last_updated__lte: Option<Vec<String>>,
2304    last_updated__n: Option<Vec<String>>,
2305    limit: Option<i32>,
2306    locations: Option<Vec<String>>,
2307    locations__isnull: Option<bool>,
2308    locations__n: Option<Vec<String>>,
2309    name: Option<Vec<String>>,
2310    name__ic: Option<Vec<String>>,
2311    name__ie: Option<Vec<String>>,
2312    name__iew: Option<Vec<String>>,
2313    name__ire: Option<Vec<String>>,
2314    name__isw: Option<Vec<String>>,
2315    name__n: Option<Vec<String>>,
2316    name__nic: Option<Vec<String>>,
2317    name__nie: Option<Vec<String>>,
2318    name__niew: Option<Vec<String>>,
2319    name__nire: Option<Vec<String>>,
2320    name__nisw: Option<Vec<String>>,
2321    name__nre: Option<Vec<String>>,
2322    name__re: Option<Vec<String>>,
2323    offset: Option<i32>,
2324    prefixes: Option<Vec<String>>,
2325    prefixes__isnull: Option<bool>,
2326    prefixes__n: Option<Vec<String>>,
2327    q: Option<&str>,
2328    rack_reservations: Option<Vec<uuid::Uuid>>,
2329    rack_reservations__isnull: Option<bool>,
2330    rack_reservations__n: Option<Vec<uuid::Uuid>>,
2331    racks: Option<Vec<String>>,
2332    racks__isnull: Option<bool>,
2333    racks__n: Option<Vec<String>>,
2334    route_targets: Option<Vec<String>>,
2335    route_targets__isnull: Option<bool>,
2336    route_targets__n: Option<Vec<String>>,
2337    sort: Option<&str>,
2338    tags: Option<Vec<String>>,
2339    tags__isnull: Option<bool>,
2340    tags__n: Option<Vec<String>>,
2341    teams: Option<Vec<String>>,
2342    teams__isnull: Option<bool>,
2343    teams__n: Option<Vec<String>>,
2344    tenant_group: Option<Vec<String>>,
2345    tenant_group__isnull: Option<bool>,
2346    tenant_group__n: Option<Vec<String>>,
2347    virtual_machines: Option<Vec<String>>,
2348    virtual_machines__isnull: Option<bool>,
2349    virtual_machines__n: Option<Vec<String>>,
2350    vlans: Option<Vec<uuid::Uuid>>,
2351    vlans__isnull: Option<bool>,
2352    vlans__n: Option<Vec<uuid::Uuid>>,
2353    vrfs: Option<Vec<String>>,
2354    vrfs__isnull: Option<bool>,
2355    vrfs__n: Option<Vec<String>>,
2356    depth: Option<i32>,
2357    exclude_m2m: Option<bool>,
2358) -> Result<crate::models::PaginatedTenantList, Error<TenancyTenantsListError>> {
2359    let local_var_configuration = configuration;
2360
2361    let local_var_client = &local_var_configuration.client;
2362
2363    let local_var_uri_str = format!("{}/tenancy/tenants/", local_var_configuration.base_path);
2364    let mut local_var_req_builder =
2365        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2366
2367    if let Some(ref local_var_str) = circuits {
2368        local_var_req_builder = match "multi" {
2369            "multi" => local_var_req_builder.query(
2370                &local_var_str
2371                    .into_iter()
2372                    .map(|p| ("circuits".to_owned(), p.to_string()))
2373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2374            ),
2375            _ => local_var_req_builder.query(&[(
2376                "circuits",
2377                &local_var_str
2378                    .into_iter()
2379                    .map(|p| p.to_string())
2380                    .collect::<Vec<String>>()
2381                    .join(",")
2382                    .to_string(),
2383            )]),
2384        };
2385    }
2386    if let Some(ref local_var_str) = circuits__isnull {
2387        local_var_req_builder =
2388            local_var_req_builder.query(&[("circuits__isnull", &local_var_str.to_string())]);
2389    }
2390    if let Some(ref local_var_str) = circuits__n {
2391        local_var_req_builder = match "multi" {
2392            "multi" => local_var_req_builder.query(
2393                &local_var_str
2394                    .into_iter()
2395                    .map(|p| ("circuits__n".to_owned(), p.to_string()))
2396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2397            ),
2398            _ => local_var_req_builder.query(&[(
2399                "circuits__n",
2400                &local_var_str
2401                    .into_iter()
2402                    .map(|p| p.to_string())
2403                    .collect::<Vec<String>>()
2404                    .join(",")
2405                    .to_string(),
2406            )]),
2407        };
2408    }
2409    if let Some(ref local_var_str) = clusters {
2410        local_var_req_builder = match "multi" {
2411            "multi" => local_var_req_builder.query(
2412                &local_var_str
2413                    .into_iter()
2414                    .map(|p| ("clusters".to_owned(), p.to_string()))
2415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2416            ),
2417            _ => local_var_req_builder.query(&[(
2418                "clusters",
2419                &local_var_str
2420                    .into_iter()
2421                    .map(|p| p.to_string())
2422                    .collect::<Vec<String>>()
2423                    .join(",")
2424                    .to_string(),
2425            )]),
2426        };
2427    }
2428    if let Some(ref local_var_str) = clusters__isnull {
2429        local_var_req_builder =
2430            local_var_req_builder.query(&[("clusters__isnull", &local_var_str.to_string())]);
2431    }
2432    if let Some(ref local_var_str) = clusters__n {
2433        local_var_req_builder = match "multi" {
2434            "multi" => local_var_req_builder.query(
2435                &local_var_str
2436                    .into_iter()
2437                    .map(|p| ("clusters__n".to_owned(), p.to_string()))
2438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2439            ),
2440            _ => local_var_req_builder.query(&[(
2441                "clusters__n",
2442                &local_var_str
2443                    .into_iter()
2444                    .map(|p| p.to_string())
2445                    .collect::<Vec<String>>()
2446                    .join(",")
2447                    .to_string(),
2448            )]),
2449        };
2450    }
2451    if let Some(ref local_var_str) = comments {
2452        local_var_req_builder = match "multi" {
2453            "multi" => local_var_req_builder.query(
2454                &local_var_str
2455                    .into_iter()
2456                    .map(|p| ("comments".to_owned(), p.to_string()))
2457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2458            ),
2459            _ => local_var_req_builder.query(&[(
2460                "comments",
2461                &local_var_str
2462                    .into_iter()
2463                    .map(|p| p.to_string())
2464                    .collect::<Vec<String>>()
2465                    .join(",")
2466                    .to_string(),
2467            )]),
2468        };
2469    }
2470    if let Some(ref local_var_str) = comments__ic {
2471        local_var_req_builder = match "multi" {
2472            "multi" => local_var_req_builder.query(
2473                &local_var_str
2474                    .into_iter()
2475                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
2476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2477            ),
2478            _ => local_var_req_builder.query(&[(
2479                "comments__ic",
2480                &local_var_str
2481                    .into_iter()
2482                    .map(|p| p.to_string())
2483                    .collect::<Vec<String>>()
2484                    .join(",")
2485                    .to_string(),
2486            )]),
2487        };
2488    }
2489    if let Some(ref local_var_str) = comments__ie {
2490        local_var_req_builder = match "multi" {
2491            "multi" => local_var_req_builder.query(
2492                &local_var_str
2493                    .into_iter()
2494                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
2495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2496            ),
2497            _ => local_var_req_builder.query(&[(
2498                "comments__ie",
2499                &local_var_str
2500                    .into_iter()
2501                    .map(|p| p.to_string())
2502                    .collect::<Vec<String>>()
2503                    .join(",")
2504                    .to_string(),
2505            )]),
2506        };
2507    }
2508    if let Some(ref local_var_str) = comments__iew {
2509        local_var_req_builder = match "multi" {
2510            "multi" => local_var_req_builder.query(
2511                &local_var_str
2512                    .into_iter()
2513                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
2514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2515            ),
2516            _ => local_var_req_builder.query(&[(
2517                "comments__iew",
2518                &local_var_str
2519                    .into_iter()
2520                    .map(|p| p.to_string())
2521                    .collect::<Vec<String>>()
2522                    .join(",")
2523                    .to_string(),
2524            )]),
2525        };
2526    }
2527    if let Some(ref local_var_str) = comments__ire {
2528        local_var_req_builder = match "multi" {
2529            "multi" => local_var_req_builder.query(
2530                &local_var_str
2531                    .into_iter()
2532                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
2533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2534            ),
2535            _ => local_var_req_builder.query(&[(
2536                "comments__ire",
2537                &local_var_str
2538                    .into_iter()
2539                    .map(|p| p.to_string())
2540                    .collect::<Vec<String>>()
2541                    .join(",")
2542                    .to_string(),
2543            )]),
2544        };
2545    }
2546    if let Some(ref local_var_str) = comments__isw {
2547        local_var_req_builder = match "multi" {
2548            "multi" => local_var_req_builder.query(
2549                &local_var_str
2550                    .into_iter()
2551                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
2552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2553            ),
2554            _ => local_var_req_builder.query(&[(
2555                "comments__isw",
2556                &local_var_str
2557                    .into_iter()
2558                    .map(|p| p.to_string())
2559                    .collect::<Vec<String>>()
2560                    .join(",")
2561                    .to_string(),
2562            )]),
2563        };
2564    }
2565    if let Some(ref local_var_str) = comments__n {
2566        local_var_req_builder = match "multi" {
2567            "multi" => local_var_req_builder.query(
2568                &local_var_str
2569                    .into_iter()
2570                    .map(|p| ("comments__n".to_owned(), p.to_string()))
2571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2572            ),
2573            _ => local_var_req_builder.query(&[(
2574                "comments__n",
2575                &local_var_str
2576                    .into_iter()
2577                    .map(|p| p.to_string())
2578                    .collect::<Vec<String>>()
2579                    .join(",")
2580                    .to_string(),
2581            )]),
2582        };
2583    }
2584    if let Some(ref local_var_str) = comments__nic {
2585        local_var_req_builder = match "multi" {
2586            "multi" => local_var_req_builder.query(
2587                &local_var_str
2588                    .into_iter()
2589                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
2590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2591            ),
2592            _ => local_var_req_builder.query(&[(
2593                "comments__nic",
2594                &local_var_str
2595                    .into_iter()
2596                    .map(|p| p.to_string())
2597                    .collect::<Vec<String>>()
2598                    .join(",")
2599                    .to_string(),
2600            )]),
2601        };
2602    }
2603    if let Some(ref local_var_str) = comments__nie {
2604        local_var_req_builder = match "multi" {
2605            "multi" => local_var_req_builder.query(
2606                &local_var_str
2607                    .into_iter()
2608                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
2609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2610            ),
2611            _ => local_var_req_builder.query(&[(
2612                "comments__nie",
2613                &local_var_str
2614                    .into_iter()
2615                    .map(|p| p.to_string())
2616                    .collect::<Vec<String>>()
2617                    .join(",")
2618                    .to_string(),
2619            )]),
2620        };
2621    }
2622    if let Some(ref local_var_str) = comments__niew {
2623        local_var_req_builder = match "multi" {
2624            "multi" => local_var_req_builder.query(
2625                &local_var_str
2626                    .into_iter()
2627                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
2628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2629            ),
2630            _ => local_var_req_builder.query(&[(
2631                "comments__niew",
2632                &local_var_str
2633                    .into_iter()
2634                    .map(|p| p.to_string())
2635                    .collect::<Vec<String>>()
2636                    .join(",")
2637                    .to_string(),
2638            )]),
2639        };
2640    }
2641    if let Some(ref local_var_str) = comments__nire {
2642        local_var_req_builder = match "multi" {
2643            "multi" => local_var_req_builder.query(
2644                &local_var_str
2645                    .into_iter()
2646                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
2647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2648            ),
2649            _ => local_var_req_builder.query(&[(
2650                "comments__nire",
2651                &local_var_str
2652                    .into_iter()
2653                    .map(|p| p.to_string())
2654                    .collect::<Vec<String>>()
2655                    .join(",")
2656                    .to_string(),
2657            )]),
2658        };
2659    }
2660    if let Some(ref local_var_str) = comments__nisw {
2661        local_var_req_builder = match "multi" {
2662            "multi" => local_var_req_builder.query(
2663                &local_var_str
2664                    .into_iter()
2665                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
2666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2667            ),
2668            _ => local_var_req_builder.query(&[(
2669                "comments__nisw",
2670                &local_var_str
2671                    .into_iter()
2672                    .map(|p| p.to_string())
2673                    .collect::<Vec<String>>()
2674                    .join(",")
2675                    .to_string(),
2676            )]),
2677        };
2678    }
2679    if let Some(ref local_var_str) = comments__nre {
2680        local_var_req_builder = match "multi" {
2681            "multi" => local_var_req_builder.query(
2682                &local_var_str
2683                    .into_iter()
2684                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
2685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2686            ),
2687            _ => local_var_req_builder.query(&[(
2688                "comments__nre",
2689                &local_var_str
2690                    .into_iter()
2691                    .map(|p| p.to_string())
2692                    .collect::<Vec<String>>()
2693                    .join(",")
2694                    .to_string(),
2695            )]),
2696        };
2697    }
2698    if let Some(ref local_var_str) = comments__re {
2699        local_var_req_builder = match "multi" {
2700            "multi" => local_var_req_builder.query(
2701                &local_var_str
2702                    .into_iter()
2703                    .map(|p| ("comments__re".to_owned(), p.to_string()))
2704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2705            ),
2706            _ => local_var_req_builder.query(&[(
2707                "comments__re",
2708                &local_var_str
2709                    .into_iter()
2710                    .map(|p| p.to_string())
2711                    .collect::<Vec<String>>()
2712                    .join(",")
2713                    .to_string(),
2714            )]),
2715        };
2716    }
2717    if let Some(ref local_var_str) = contacts {
2718        local_var_req_builder = match "multi" {
2719            "multi" => local_var_req_builder.query(
2720                &local_var_str
2721                    .into_iter()
2722                    .map(|p| ("contacts".to_owned(), p.to_string()))
2723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2724            ),
2725            _ => local_var_req_builder.query(&[(
2726                "contacts",
2727                &local_var_str
2728                    .into_iter()
2729                    .map(|p| p.to_string())
2730                    .collect::<Vec<String>>()
2731                    .join(",")
2732                    .to_string(),
2733            )]),
2734        };
2735    }
2736    if let Some(ref local_var_str) = contacts__isnull {
2737        local_var_req_builder =
2738            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
2739    }
2740    if let Some(ref local_var_str) = contacts__n {
2741        local_var_req_builder = match "multi" {
2742            "multi" => local_var_req_builder.query(
2743                &local_var_str
2744                    .into_iter()
2745                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
2746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2747            ),
2748            _ => local_var_req_builder.query(&[(
2749                "contacts__n",
2750                &local_var_str
2751                    .into_iter()
2752                    .map(|p| p.to_string())
2753                    .collect::<Vec<String>>()
2754                    .join(",")
2755                    .to_string(),
2756            )]),
2757        };
2758    }
2759    if let Some(ref local_var_str) = created {
2760        local_var_req_builder = match "multi" {
2761            "multi" => local_var_req_builder.query(
2762                &local_var_str
2763                    .into_iter()
2764                    .map(|p| ("created".to_owned(), p.to_string()))
2765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2766            ),
2767            _ => local_var_req_builder.query(&[(
2768                "created",
2769                &local_var_str
2770                    .into_iter()
2771                    .map(|p| p.to_string())
2772                    .collect::<Vec<String>>()
2773                    .join(",")
2774                    .to_string(),
2775            )]),
2776        };
2777    }
2778    if let Some(ref local_var_str) = created__gt {
2779        local_var_req_builder = match "multi" {
2780            "multi" => local_var_req_builder.query(
2781                &local_var_str
2782                    .into_iter()
2783                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2785            ),
2786            _ => local_var_req_builder.query(&[(
2787                "created__gt",
2788                &local_var_str
2789                    .into_iter()
2790                    .map(|p| p.to_string())
2791                    .collect::<Vec<String>>()
2792                    .join(",")
2793                    .to_string(),
2794            )]),
2795        };
2796    }
2797    if let Some(ref local_var_str) = created__gte {
2798        local_var_req_builder = match "multi" {
2799            "multi" => local_var_req_builder.query(
2800                &local_var_str
2801                    .into_iter()
2802                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2804            ),
2805            _ => local_var_req_builder.query(&[(
2806                "created__gte",
2807                &local_var_str
2808                    .into_iter()
2809                    .map(|p| p.to_string())
2810                    .collect::<Vec<String>>()
2811                    .join(",")
2812                    .to_string(),
2813            )]),
2814        };
2815    }
2816    if let Some(ref local_var_str) = created__isnull {
2817        local_var_req_builder =
2818            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
2819    }
2820    if let Some(ref local_var_str) = created__lt {
2821        local_var_req_builder = match "multi" {
2822            "multi" => local_var_req_builder.query(
2823                &local_var_str
2824                    .into_iter()
2825                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2827            ),
2828            _ => local_var_req_builder.query(&[(
2829                "created__lt",
2830                &local_var_str
2831                    .into_iter()
2832                    .map(|p| p.to_string())
2833                    .collect::<Vec<String>>()
2834                    .join(",")
2835                    .to_string(),
2836            )]),
2837        };
2838    }
2839    if let Some(ref local_var_str) = created__lte {
2840        local_var_req_builder = match "multi" {
2841            "multi" => local_var_req_builder.query(
2842                &local_var_str
2843                    .into_iter()
2844                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2846            ),
2847            _ => local_var_req_builder.query(&[(
2848                "created__lte",
2849                &local_var_str
2850                    .into_iter()
2851                    .map(|p| p.to_string())
2852                    .collect::<Vec<String>>()
2853                    .join(",")
2854                    .to_string(),
2855            )]),
2856        };
2857    }
2858    if let Some(ref local_var_str) = created__n {
2859        local_var_req_builder = match "multi" {
2860            "multi" => local_var_req_builder.query(
2861                &local_var_str
2862                    .into_iter()
2863                    .map(|p| ("created__n".to_owned(), p.to_string()))
2864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2865            ),
2866            _ => local_var_req_builder.query(&[(
2867                "created__n",
2868                &local_var_str
2869                    .into_iter()
2870                    .map(|p| p.to_string())
2871                    .collect::<Vec<String>>()
2872                    .join(",")
2873                    .to_string(),
2874            )]),
2875        };
2876    }
2877    if let Some(ref local_var_str) = description {
2878        local_var_req_builder = match "multi" {
2879            "multi" => local_var_req_builder.query(
2880                &local_var_str
2881                    .into_iter()
2882                    .map(|p| ("description".to_owned(), p.to_string()))
2883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2884            ),
2885            _ => local_var_req_builder.query(&[(
2886                "description",
2887                &local_var_str
2888                    .into_iter()
2889                    .map(|p| p.to_string())
2890                    .collect::<Vec<String>>()
2891                    .join(",")
2892                    .to_string(),
2893            )]),
2894        };
2895    }
2896    if let Some(ref local_var_str) = description__ic {
2897        local_var_req_builder = match "multi" {
2898            "multi" => local_var_req_builder.query(
2899                &local_var_str
2900                    .into_iter()
2901                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2903            ),
2904            _ => local_var_req_builder.query(&[(
2905                "description__ic",
2906                &local_var_str
2907                    .into_iter()
2908                    .map(|p| p.to_string())
2909                    .collect::<Vec<String>>()
2910                    .join(",")
2911                    .to_string(),
2912            )]),
2913        };
2914    }
2915    if let Some(ref local_var_str) = description__ie {
2916        local_var_req_builder = match "multi" {
2917            "multi" => local_var_req_builder.query(
2918                &local_var_str
2919                    .into_iter()
2920                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2922            ),
2923            _ => local_var_req_builder.query(&[(
2924                "description__ie",
2925                &local_var_str
2926                    .into_iter()
2927                    .map(|p| p.to_string())
2928                    .collect::<Vec<String>>()
2929                    .join(",")
2930                    .to_string(),
2931            )]),
2932        };
2933    }
2934    if let Some(ref local_var_str) = description__iew {
2935        local_var_req_builder = match "multi" {
2936            "multi" => local_var_req_builder.query(
2937                &local_var_str
2938                    .into_iter()
2939                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2941            ),
2942            _ => local_var_req_builder.query(&[(
2943                "description__iew",
2944                &local_var_str
2945                    .into_iter()
2946                    .map(|p| p.to_string())
2947                    .collect::<Vec<String>>()
2948                    .join(",")
2949                    .to_string(),
2950            )]),
2951        };
2952    }
2953    if let Some(ref local_var_str) = description__ire {
2954        local_var_req_builder = match "multi" {
2955            "multi" => local_var_req_builder.query(
2956                &local_var_str
2957                    .into_iter()
2958                    .map(|p| ("description__ire".to_owned(), p.to_string()))
2959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2960            ),
2961            _ => local_var_req_builder.query(&[(
2962                "description__ire",
2963                &local_var_str
2964                    .into_iter()
2965                    .map(|p| p.to_string())
2966                    .collect::<Vec<String>>()
2967                    .join(",")
2968                    .to_string(),
2969            )]),
2970        };
2971    }
2972    if let Some(ref local_var_str) = description__isw {
2973        local_var_req_builder = match "multi" {
2974            "multi" => local_var_req_builder.query(
2975                &local_var_str
2976                    .into_iter()
2977                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2979            ),
2980            _ => local_var_req_builder.query(&[(
2981                "description__isw",
2982                &local_var_str
2983                    .into_iter()
2984                    .map(|p| p.to_string())
2985                    .collect::<Vec<String>>()
2986                    .join(",")
2987                    .to_string(),
2988            )]),
2989        };
2990    }
2991    if let Some(ref local_var_str) = description__n {
2992        local_var_req_builder = match "multi" {
2993            "multi" => local_var_req_builder.query(
2994                &local_var_str
2995                    .into_iter()
2996                    .map(|p| ("description__n".to_owned(), p.to_string()))
2997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2998            ),
2999            _ => local_var_req_builder.query(&[(
3000                "description__n",
3001                &local_var_str
3002                    .into_iter()
3003                    .map(|p| p.to_string())
3004                    .collect::<Vec<String>>()
3005                    .join(",")
3006                    .to_string(),
3007            )]),
3008        };
3009    }
3010    if let Some(ref local_var_str) = description__nic {
3011        local_var_req_builder = match "multi" {
3012            "multi" => local_var_req_builder.query(
3013                &local_var_str
3014                    .into_iter()
3015                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3017            ),
3018            _ => local_var_req_builder.query(&[(
3019                "description__nic",
3020                &local_var_str
3021                    .into_iter()
3022                    .map(|p| p.to_string())
3023                    .collect::<Vec<String>>()
3024                    .join(",")
3025                    .to_string(),
3026            )]),
3027        };
3028    }
3029    if let Some(ref local_var_str) = description__nie {
3030        local_var_req_builder = match "multi" {
3031            "multi" => local_var_req_builder.query(
3032                &local_var_str
3033                    .into_iter()
3034                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3036            ),
3037            _ => local_var_req_builder.query(&[(
3038                "description__nie",
3039                &local_var_str
3040                    .into_iter()
3041                    .map(|p| p.to_string())
3042                    .collect::<Vec<String>>()
3043                    .join(",")
3044                    .to_string(),
3045            )]),
3046        };
3047    }
3048    if let Some(ref local_var_str) = description__niew {
3049        local_var_req_builder = match "multi" {
3050            "multi" => local_var_req_builder.query(
3051                &local_var_str
3052                    .into_iter()
3053                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3055            ),
3056            _ => local_var_req_builder.query(&[(
3057                "description__niew",
3058                &local_var_str
3059                    .into_iter()
3060                    .map(|p| p.to_string())
3061                    .collect::<Vec<String>>()
3062                    .join(",")
3063                    .to_string(),
3064            )]),
3065        };
3066    }
3067    if let Some(ref local_var_str) = description__nire {
3068        local_var_req_builder = match "multi" {
3069            "multi" => local_var_req_builder.query(
3070                &local_var_str
3071                    .into_iter()
3072                    .map(|p| ("description__nire".to_owned(), p.to_string()))
3073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3074            ),
3075            _ => local_var_req_builder.query(&[(
3076                "description__nire",
3077                &local_var_str
3078                    .into_iter()
3079                    .map(|p| p.to_string())
3080                    .collect::<Vec<String>>()
3081                    .join(",")
3082                    .to_string(),
3083            )]),
3084        };
3085    }
3086    if let Some(ref local_var_str) = description__nisw {
3087        local_var_req_builder = match "multi" {
3088            "multi" => local_var_req_builder.query(
3089                &local_var_str
3090                    .into_iter()
3091                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3093            ),
3094            _ => local_var_req_builder.query(&[(
3095                "description__nisw",
3096                &local_var_str
3097                    .into_iter()
3098                    .map(|p| p.to_string())
3099                    .collect::<Vec<String>>()
3100                    .join(",")
3101                    .to_string(),
3102            )]),
3103        };
3104    }
3105    if let Some(ref local_var_str) = description__nre {
3106        local_var_req_builder = match "multi" {
3107            "multi" => local_var_req_builder.query(
3108                &local_var_str
3109                    .into_iter()
3110                    .map(|p| ("description__nre".to_owned(), p.to_string()))
3111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3112            ),
3113            _ => local_var_req_builder.query(&[(
3114                "description__nre",
3115                &local_var_str
3116                    .into_iter()
3117                    .map(|p| p.to_string())
3118                    .collect::<Vec<String>>()
3119                    .join(",")
3120                    .to_string(),
3121            )]),
3122        };
3123    }
3124    if let Some(ref local_var_str) = description__re {
3125        local_var_req_builder = match "multi" {
3126            "multi" => local_var_req_builder.query(
3127                &local_var_str
3128                    .into_iter()
3129                    .map(|p| ("description__re".to_owned(), p.to_string()))
3130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3131            ),
3132            _ => local_var_req_builder.query(&[(
3133                "description__re",
3134                &local_var_str
3135                    .into_iter()
3136                    .map(|p| p.to_string())
3137                    .collect::<Vec<String>>()
3138                    .join(",")
3139                    .to_string(),
3140            )]),
3141        };
3142    }
3143    if let Some(ref local_var_str) = devices {
3144        local_var_req_builder = match "multi" {
3145            "multi" => local_var_req_builder.query(
3146                &local_var_str
3147                    .into_iter()
3148                    .map(|p| ("devices".to_owned(), p.to_string()))
3149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3150            ),
3151            _ => local_var_req_builder.query(&[(
3152                "devices",
3153                &local_var_str
3154                    .into_iter()
3155                    .map(|p| p.to_string())
3156                    .collect::<Vec<String>>()
3157                    .join(",")
3158                    .to_string(),
3159            )]),
3160        };
3161    }
3162    if let Some(ref local_var_str) = devices__isnull {
3163        local_var_req_builder =
3164            local_var_req_builder.query(&[("devices__isnull", &local_var_str.to_string())]);
3165    }
3166    if let Some(ref local_var_str) = devices__n {
3167        local_var_req_builder = match "multi" {
3168            "multi" => local_var_req_builder.query(
3169                &local_var_str
3170                    .into_iter()
3171                    .map(|p| ("devices__n".to_owned(), p.to_string()))
3172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3173            ),
3174            _ => local_var_req_builder.query(&[(
3175                "devices__n",
3176                &local_var_str
3177                    .into_iter()
3178                    .map(|p| p.to_string())
3179                    .collect::<Vec<String>>()
3180                    .join(",")
3181                    .to_string(),
3182            )]),
3183        };
3184    }
3185    if let Some(ref local_var_str) = dynamic_groups {
3186        local_var_req_builder = match "multi" {
3187            "multi" => local_var_req_builder.query(
3188                &local_var_str
3189                    .into_iter()
3190                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
3191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3192            ),
3193            _ => local_var_req_builder.query(&[(
3194                "dynamic_groups",
3195                &local_var_str
3196                    .into_iter()
3197                    .map(|p| p.to_string())
3198                    .collect::<Vec<String>>()
3199                    .join(",")
3200                    .to_string(),
3201            )]),
3202        };
3203    }
3204    if let Some(ref local_var_str) = dynamic_groups__n {
3205        local_var_req_builder = match "multi" {
3206            "multi" => local_var_req_builder.query(
3207                &local_var_str
3208                    .into_iter()
3209                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
3210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3211            ),
3212            _ => local_var_req_builder.query(&[(
3213                "dynamic_groups__n",
3214                &local_var_str
3215                    .into_iter()
3216                    .map(|p| p.to_string())
3217                    .collect::<Vec<String>>()
3218                    .join(",")
3219                    .to_string(),
3220            )]),
3221        };
3222    }
3223    if let Some(ref local_var_str) = format {
3224        local_var_req_builder =
3225            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3226    }
3227    if let Some(ref local_var_str) = has_circuits {
3228        local_var_req_builder =
3229            local_var_req_builder.query(&[("has_circuits", &local_var_str.to_string())]);
3230    }
3231    if let Some(ref local_var_str) = has_clusters {
3232        local_var_req_builder =
3233            local_var_req_builder.query(&[("has_clusters", &local_var_str.to_string())]);
3234    }
3235    if let Some(ref local_var_str) = has_devices {
3236        local_var_req_builder =
3237            local_var_req_builder.query(&[("has_devices", &local_var_str.to_string())]);
3238    }
3239    if let Some(ref local_var_str) = has_ip_addresses {
3240        local_var_req_builder =
3241            local_var_req_builder.query(&[("has_ip_addresses", &local_var_str.to_string())]);
3242    }
3243    if let Some(ref local_var_str) = has_locations {
3244        local_var_req_builder =
3245            local_var_req_builder.query(&[("has_locations", &local_var_str.to_string())]);
3246    }
3247    if let Some(ref local_var_str) = has_prefixes {
3248        local_var_req_builder =
3249            local_var_req_builder.query(&[("has_prefixes", &local_var_str.to_string())]);
3250    }
3251    if let Some(ref local_var_str) = has_rack_reservations {
3252        local_var_req_builder =
3253            local_var_req_builder.query(&[("has_rack_reservations", &local_var_str.to_string())]);
3254    }
3255    if let Some(ref local_var_str) = has_racks {
3256        local_var_req_builder =
3257            local_var_req_builder.query(&[("has_racks", &local_var_str.to_string())]);
3258    }
3259    if let Some(ref local_var_str) = has_route_targets {
3260        local_var_req_builder =
3261            local_var_req_builder.query(&[("has_route_targets", &local_var_str.to_string())]);
3262    }
3263    if let Some(ref local_var_str) = has_virtual_machines {
3264        local_var_req_builder =
3265            local_var_req_builder.query(&[("has_virtual_machines", &local_var_str.to_string())]);
3266    }
3267    if let Some(ref local_var_str) = has_vlans {
3268        local_var_req_builder =
3269            local_var_req_builder.query(&[("has_vlans", &local_var_str.to_string())]);
3270    }
3271    if let Some(ref local_var_str) = has_vrfs {
3272        local_var_req_builder =
3273            local_var_req_builder.query(&[("has_vrfs", &local_var_str.to_string())]);
3274    }
3275    if let Some(ref local_var_str) = id {
3276        local_var_req_builder = match "multi" {
3277            "multi" => local_var_req_builder.query(
3278                &local_var_str
3279                    .into_iter()
3280                    .map(|p| ("id".to_owned(), p.to_string()))
3281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3282            ),
3283            _ => local_var_req_builder.query(&[(
3284                "id",
3285                &local_var_str
3286                    .into_iter()
3287                    .map(|p| p.to_string())
3288                    .collect::<Vec<String>>()
3289                    .join(",")
3290                    .to_string(),
3291            )]),
3292        };
3293    }
3294    if let Some(ref local_var_str) = id__n {
3295        local_var_req_builder = match "multi" {
3296            "multi" => local_var_req_builder.query(
3297                &local_var_str
3298                    .into_iter()
3299                    .map(|p| ("id__n".to_owned(), p.to_string()))
3300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3301            ),
3302            _ => local_var_req_builder.query(&[(
3303                "id__n",
3304                &local_var_str
3305                    .into_iter()
3306                    .map(|p| p.to_string())
3307                    .collect::<Vec<String>>()
3308                    .join(",")
3309                    .to_string(),
3310            )]),
3311        };
3312    }
3313    if let Some(ref local_var_str) = ip_addresses {
3314        local_var_req_builder = match "multi" {
3315            "multi" => local_var_req_builder.query(
3316                &local_var_str
3317                    .into_iter()
3318                    .map(|p| ("ip_addresses".to_owned(), p.to_string()))
3319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3320            ),
3321            _ => local_var_req_builder.query(&[(
3322                "ip_addresses",
3323                &local_var_str
3324                    .into_iter()
3325                    .map(|p| p.to_string())
3326                    .collect::<Vec<String>>()
3327                    .join(",")
3328                    .to_string(),
3329            )]),
3330        };
3331    }
3332    if let Some(ref local_var_str) = ip_addresses__isnull {
3333        local_var_req_builder =
3334            local_var_req_builder.query(&[("ip_addresses__isnull", &local_var_str.to_string())]);
3335    }
3336    if let Some(ref local_var_str) = ip_addresses__n {
3337        local_var_req_builder = match "multi" {
3338            "multi" => local_var_req_builder.query(
3339                &local_var_str
3340                    .into_iter()
3341                    .map(|p| ("ip_addresses__n".to_owned(), p.to_string()))
3342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3343            ),
3344            _ => local_var_req_builder.query(&[(
3345                "ip_addresses__n",
3346                &local_var_str
3347                    .into_iter()
3348                    .map(|p| p.to_string())
3349                    .collect::<Vec<String>>()
3350                    .join(",")
3351                    .to_string(),
3352            )]),
3353        };
3354    }
3355    if let Some(ref local_var_str) = last_updated {
3356        local_var_req_builder = match "multi" {
3357            "multi" => local_var_req_builder.query(
3358                &local_var_str
3359                    .into_iter()
3360                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3362            ),
3363            _ => local_var_req_builder.query(&[(
3364                "last_updated",
3365                &local_var_str
3366                    .into_iter()
3367                    .map(|p| p.to_string())
3368                    .collect::<Vec<String>>()
3369                    .join(",")
3370                    .to_string(),
3371            )]),
3372        };
3373    }
3374    if let Some(ref local_var_str) = last_updated__gt {
3375        local_var_req_builder = match "multi" {
3376            "multi" => local_var_req_builder.query(
3377                &local_var_str
3378                    .into_iter()
3379                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3381            ),
3382            _ => local_var_req_builder.query(&[(
3383                "last_updated__gt",
3384                &local_var_str
3385                    .into_iter()
3386                    .map(|p| p.to_string())
3387                    .collect::<Vec<String>>()
3388                    .join(",")
3389                    .to_string(),
3390            )]),
3391        };
3392    }
3393    if let Some(ref local_var_str) = last_updated__gte {
3394        local_var_req_builder = match "multi" {
3395            "multi" => local_var_req_builder.query(
3396                &local_var_str
3397                    .into_iter()
3398                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3400            ),
3401            _ => local_var_req_builder.query(&[(
3402                "last_updated__gte",
3403                &local_var_str
3404                    .into_iter()
3405                    .map(|p| p.to_string())
3406                    .collect::<Vec<String>>()
3407                    .join(",")
3408                    .to_string(),
3409            )]),
3410        };
3411    }
3412    if let Some(ref local_var_str) = last_updated__isnull {
3413        local_var_req_builder =
3414            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
3415    }
3416    if let Some(ref local_var_str) = last_updated__lt {
3417        local_var_req_builder = match "multi" {
3418            "multi" => local_var_req_builder.query(
3419                &local_var_str
3420                    .into_iter()
3421                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3423            ),
3424            _ => local_var_req_builder.query(&[(
3425                "last_updated__lt",
3426                &local_var_str
3427                    .into_iter()
3428                    .map(|p| p.to_string())
3429                    .collect::<Vec<String>>()
3430                    .join(",")
3431                    .to_string(),
3432            )]),
3433        };
3434    }
3435    if let Some(ref local_var_str) = last_updated__lte {
3436        local_var_req_builder = match "multi" {
3437            "multi" => local_var_req_builder.query(
3438                &local_var_str
3439                    .into_iter()
3440                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3442            ),
3443            _ => local_var_req_builder.query(&[(
3444                "last_updated__lte",
3445                &local_var_str
3446                    .into_iter()
3447                    .map(|p| p.to_string())
3448                    .collect::<Vec<String>>()
3449                    .join(",")
3450                    .to_string(),
3451            )]),
3452        };
3453    }
3454    if let Some(ref local_var_str) = last_updated__n {
3455        local_var_req_builder = match "multi" {
3456            "multi" => local_var_req_builder.query(
3457                &local_var_str
3458                    .into_iter()
3459                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3461            ),
3462            _ => local_var_req_builder.query(&[(
3463                "last_updated__n",
3464                &local_var_str
3465                    .into_iter()
3466                    .map(|p| p.to_string())
3467                    .collect::<Vec<String>>()
3468                    .join(",")
3469                    .to_string(),
3470            )]),
3471        };
3472    }
3473    if let Some(ref local_var_str) = limit {
3474        local_var_req_builder =
3475            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3476    }
3477    if let Some(ref local_var_str) = locations {
3478        local_var_req_builder = match "multi" {
3479            "multi" => local_var_req_builder.query(
3480                &local_var_str
3481                    .into_iter()
3482                    .map(|p| ("locations".to_owned(), p.to_string()))
3483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3484            ),
3485            _ => local_var_req_builder.query(&[(
3486                "locations",
3487                &local_var_str
3488                    .into_iter()
3489                    .map(|p| p.to_string())
3490                    .collect::<Vec<String>>()
3491                    .join(",")
3492                    .to_string(),
3493            )]),
3494        };
3495    }
3496    if let Some(ref local_var_str) = locations__isnull {
3497        local_var_req_builder =
3498            local_var_req_builder.query(&[("locations__isnull", &local_var_str.to_string())]);
3499    }
3500    if let Some(ref local_var_str) = locations__n {
3501        local_var_req_builder = match "multi" {
3502            "multi" => local_var_req_builder.query(
3503                &local_var_str
3504                    .into_iter()
3505                    .map(|p| ("locations__n".to_owned(), p.to_string()))
3506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3507            ),
3508            _ => local_var_req_builder.query(&[(
3509                "locations__n",
3510                &local_var_str
3511                    .into_iter()
3512                    .map(|p| p.to_string())
3513                    .collect::<Vec<String>>()
3514                    .join(",")
3515                    .to_string(),
3516            )]),
3517        };
3518    }
3519    if let Some(ref local_var_str) = name {
3520        local_var_req_builder = match "multi" {
3521            "multi" => local_var_req_builder.query(
3522                &local_var_str
3523                    .into_iter()
3524                    .map(|p| ("name".to_owned(), p.to_string()))
3525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3526            ),
3527            _ => local_var_req_builder.query(&[(
3528                "name",
3529                &local_var_str
3530                    .into_iter()
3531                    .map(|p| p.to_string())
3532                    .collect::<Vec<String>>()
3533                    .join(",")
3534                    .to_string(),
3535            )]),
3536        };
3537    }
3538    if let Some(ref local_var_str) = name__ic {
3539        local_var_req_builder = match "multi" {
3540            "multi" => local_var_req_builder.query(
3541                &local_var_str
3542                    .into_iter()
3543                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3545            ),
3546            _ => local_var_req_builder.query(&[(
3547                "name__ic",
3548                &local_var_str
3549                    .into_iter()
3550                    .map(|p| p.to_string())
3551                    .collect::<Vec<String>>()
3552                    .join(",")
3553                    .to_string(),
3554            )]),
3555        };
3556    }
3557    if let Some(ref local_var_str) = name__ie {
3558        local_var_req_builder = match "multi" {
3559            "multi" => local_var_req_builder.query(
3560                &local_var_str
3561                    .into_iter()
3562                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3564            ),
3565            _ => local_var_req_builder.query(&[(
3566                "name__ie",
3567                &local_var_str
3568                    .into_iter()
3569                    .map(|p| p.to_string())
3570                    .collect::<Vec<String>>()
3571                    .join(",")
3572                    .to_string(),
3573            )]),
3574        };
3575    }
3576    if let Some(ref local_var_str) = name__iew {
3577        local_var_req_builder = match "multi" {
3578            "multi" => local_var_req_builder.query(
3579                &local_var_str
3580                    .into_iter()
3581                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3583            ),
3584            _ => local_var_req_builder.query(&[(
3585                "name__iew",
3586                &local_var_str
3587                    .into_iter()
3588                    .map(|p| p.to_string())
3589                    .collect::<Vec<String>>()
3590                    .join(",")
3591                    .to_string(),
3592            )]),
3593        };
3594    }
3595    if let Some(ref local_var_str) = name__ire {
3596        local_var_req_builder = match "multi" {
3597            "multi" => local_var_req_builder.query(
3598                &local_var_str
3599                    .into_iter()
3600                    .map(|p| ("name__ire".to_owned(), p.to_string()))
3601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3602            ),
3603            _ => local_var_req_builder.query(&[(
3604                "name__ire",
3605                &local_var_str
3606                    .into_iter()
3607                    .map(|p| p.to_string())
3608                    .collect::<Vec<String>>()
3609                    .join(",")
3610                    .to_string(),
3611            )]),
3612        };
3613    }
3614    if let Some(ref local_var_str) = name__isw {
3615        local_var_req_builder = match "multi" {
3616            "multi" => local_var_req_builder.query(
3617                &local_var_str
3618                    .into_iter()
3619                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3621            ),
3622            _ => local_var_req_builder.query(&[(
3623                "name__isw",
3624                &local_var_str
3625                    .into_iter()
3626                    .map(|p| p.to_string())
3627                    .collect::<Vec<String>>()
3628                    .join(",")
3629                    .to_string(),
3630            )]),
3631        };
3632    }
3633    if let Some(ref local_var_str) = name__n {
3634        local_var_req_builder = match "multi" {
3635            "multi" => local_var_req_builder.query(
3636                &local_var_str
3637                    .into_iter()
3638                    .map(|p| ("name__n".to_owned(), p.to_string()))
3639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3640            ),
3641            _ => local_var_req_builder.query(&[(
3642                "name__n",
3643                &local_var_str
3644                    .into_iter()
3645                    .map(|p| p.to_string())
3646                    .collect::<Vec<String>>()
3647                    .join(",")
3648                    .to_string(),
3649            )]),
3650        };
3651    }
3652    if let Some(ref local_var_str) = name__nic {
3653        local_var_req_builder = match "multi" {
3654            "multi" => local_var_req_builder.query(
3655                &local_var_str
3656                    .into_iter()
3657                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3659            ),
3660            _ => local_var_req_builder.query(&[(
3661                "name__nic",
3662                &local_var_str
3663                    .into_iter()
3664                    .map(|p| p.to_string())
3665                    .collect::<Vec<String>>()
3666                    .join(",")
3667                    .to_string(),
3668            )]),
3669        };
3670    }
3671    if let Some(ref local_var_str) = name__nie {
3672        local_var_req_builder = match "multi" {
3673            "multi" => local_var_req_builder.query(
3674                &local_var_str
3675                    .into_iter()
3676                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3678            ),
3679            _ => local_var_req_builder.query(&[(
3680                "name__nie",
3681                &local_var_str
3682                    .into_iter()
3683                    .map(|p| p.to_string())
3684                    .collect::<Vec<String>>()
3685                    .join(",")
3686                    .to_string(),
3687            )]),
3688        };
3689    }
3690    if let Some(ref local_var_str) = name__niew {
3691        local_var_req_builder = match "multi" {
3692            "multi" => local_var_req_builder.query(
3693                &local_var_str
3694                    .into_iter()
3695                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3697            ),
3698            _ => local_var_req_builder.query(&[(
3699                "name__niew",
3700                &local_var_str
3701                    .into_iter()
3702                    .map(|p| p.to_string())
3703                    .collect::<Vec<String>>()
3704                    .join(",")
3705                    .to_string(),
3706            )]),
3707        };
3708    }
3709    if let Some(ref local_var_str) = name__nire {
3710        local_var_req_builder = match "multi" {
3711            "multi" => local_var_req_builder.query(
3712                &local_var_str
3713                    .into_iter()
3714                    .map(|p| ("name__nire".to_owned(), p.to_string()))
3715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3716            ),
3717            _ => local_var_req_builder.query(&[(
3718                "name__nire",
3719                &local_var_str
3720                    .into_iter()
3721                    .map(|p| p.to_string())
3722                    .collect::<Vec<String>>()
3723                    .join(",")
3724                    .to_string(),
3725            )]),
3726        };
3727    }
3728    if let Some(ref local_var_str) = name__nisw {
3729        local_var_req_builder = match "multi" {
3730            "multi" => local_var_req_builder.query(
3731                &local_var_str
3732                    .into_iter()
3733                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3735            ),
3736            _ => local_var_req_builder.query(&[(
3737                "name__nisw",
3738                &local_var_str
3739                    .into_iter()
3740                    .map(|p| p.to_string())
3741                    .collect::<Vec<String>>()
3742                    .join(",")
3743                    .to_string(),
3744            )]),
3745        };
3746    }
3747    if let Some(ref local_var_str) = name__nre {
3748        local_var_req_builder = match "multi" {
3749            "multi" => local_var_req_builder.query(
3750                &local_var_str
3751                    .into_iter()
3752                    .map(|p| ("name__nre".to_owned(), p.to_string()))
3753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3754            ),
3755            _ => local_var_req_builder.query(&[(
3756                "name__nre",
3757                &local_var_str
3758                    .into_iter()
3759                    .map(|p| p.to_string())
3760                    .collect::<Vec<String>>()
3761                    .join(",")
3762                    .to_string(),
3763            )]),
3764        };
3765    }
3766    if let Some(ref local_var_str) = name__re {
3767        local_var_req_builder = match "multi" {
3768            "multi" => local_var_req_builder.query(
3769                &local_var_str
3770                    .into_iter()
3771                    .map(|p| ("name__re".to_owned(), p.to_string()))
3772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3773            ),
3774            _ => local_var_req_builder.query(&[(
3775                "name__re",
3776                &local_var_str
3777                    .into_iter()
3778                    .map(|p| p.to_string())
3779                    .collect::<Vec<String>>()
3780                    .join(",")
3781                    .to_string(),
3782            )]),
3783        };
3784    }
3785    if let Some(ref local_var_str) = offset {
3786        local_var_req_builder =
3787            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3788    }
3789    if let Some(ref local_var_str) = prefixes {
3790        local_var_req_builder = match "multi" {
3791            "multi" => local_var_req_builder.query(
3792                &local_var_str
3793                    .into_iter()
3794                    .map(|p| ("prefixes".to_owned(), p.to_string()))
3795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3796            ),
3797            _ => local_var_req_builder.query(&[(
3798                "prefixes",
3799                &local_var_str
3800                    .into_iter()
3801                    .map(|p| p.to_string())
3802                    .collect::<Vec<String>>()
3803                    .join(",")
3804                    .to_string(),
3805            )]),
3806        };
3807    }
3808    if let Some(ref local_var_str) = prefixes__isnull {
3809        local_var_req_builder =
3810            local_var_req_builder.query(&[("prefixes__isnull", &local_var_str.to_string())]);
3811    }
3812    if let Some(ref local_var_str) = prefixes__n {
3813        local_var_req_builder = match "multi" {
3814            "multi" => local_var_req_builder.query(
3815                &local_var_str
3816                    .into_iter()
3817                    .map(|p| ("prefixes__n".to_owned(), p.to_string()))
3818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3819            ),
3820            _ => local_var_req_builder.query(&[(
3821                "prefixes__n",
3822                &local_var_str
3823                    .into_iter()
3824                    .map(|p| p.to_string())
3825                    .collect::<Vec<String>>()
3826                    .join(",")
3827                    .to_string(),
3828            )]),
3829        };
3830    }
3831    if let Some(ref local_var_str) = q {
3832        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3833    }
3834    if let Some(ref local_var_str) = rack_reservations {
3835        local_var_req_builder = match "multi" {
3836            "multi" => local_var_req_builder.query(
3837                &local_var_str
3838                    .into_iter()
3839                    .map(|p| ("rack_reservations".to_owned(), p.to_string()))
3840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3841            ),
3842            _ => local_var_req_builder.query(&[(
3843                "rack_reservations",
3844                &local_var_str
3845                    .into_iter()
3846                    .map(|p| p.to_string())
3847                    .collect::<Vec<String>>()
3848                    .join(",")
3849                    .to_string(),
3850            )]),
3851        };
3852    }
3853    if let Some(ref local_var_str) = rack_reservations__isnull {
3854        local_var_req_builder = local_var_req_builder
3855            .query(&[("rack_reservations__isnull", &local_var_str.to_string())]);
3856    }
3857    if let Some(ref local_var_str) = rack_reservations__n {
3858        local_var_req_builder = match "multi" {
3859            "multi" => local_var_req_builder.query(
3860                &local_var_str
3861                    .into_iter()
3862                    .map(|p| ("rack_reservations__n".to_owned(), p.to_string()))
3863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3864            ),
3865            _ => local_var_req_builder.query(&[(
3866                "rack_reservations__n",
3867                &local_var_str
3868                    .into_iter()
3869                    .map(|p| p.to_string())
3870                    .collect::<Vec<String>>()
3871                    .join(",")
3872                    .to_string(),
3873            )]),
3874        };
3875    }
3876    if let Some(ref local_var_str) = racks {
3877        local_var_req_builder = match "multi" {
3878            "multi" => local_var_req_builder.query(
3879                &local_var_str
3880                    .into_iter()
3881                    .map(|p| ("racks".to_owned(), p.to_string()))
3882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3883            ),
3884            _ => local_var_req_builder.query(&[(
3885                "racks",
3886                &local_var_str
3887                    .into_iter()
3888                    .map(|p| p.to_string())
3889                    .collect::<Vec<String>>()
3890                    .join(",")
3891                    .to_string(),
3892            )]),
3893        };
3894    }
3895    if let Some(ref local_var_str) = racks__isnull {
3896        local_var_req_builder =
3897            local_var_req_builder.query(&[("racks__isnull", &local_var_str.to_string())]);
3898    }
3899    if let Some(ref local_var_str) = racks__n {
3900        local_var_req_builder = match "multi" {
3901            "multi" => local_var_req_builder.query(
3902                &local_var_str
3903                    .into_iter()
3904                    .map(|p| ("racks__n".to_owned(), p.to_string()))
3905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3906            ),
3907            _ => local_var_req_builder.query(&[(
3908                "racks__n",
3909                &local_var_str
3910                    .into_iter()
3911                    .map(|p| p.to_string())
3912                    .collect::<Vec<String>>()
3913                    .join(",")
3914                    .to_string(),
3915            )]),
3916        };
3917    }
3918    if let Some(ref local_var_str) = route_targets {
3919        local_var_req_builder = match "multi" {
3920            "multi" => local_var_req_builder.query(
3921                &local_var_str
3922                    .into_iter()
3923                    .map(|p| ("route_targets".to_owned(), p.to_string()))
3924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3925            ),
3926            _ => local_var_req_builder.query(&[(
3927                "route_targets",
3928                &local_var_str
3929                    .into_iter()
3930                    .map(|p| p.to_string())
3931                    .collect::<Vec<String>>()
3932                    .join(",")
3933                    .to_string(),
3934            )]),
3935        };
3936    }
3937    if let Some(ref local_var_str) = route_targets__isnull {
3938        local_var_req_builder =
3939            local_var_req_builder.query(&[("route_targets__isnull", &local_var_str.to_string())]);
3940    }
3941    if let Some(ref local_var_str) = route_targets__n {
3942        local_var_req_builder = match "multi" {
3943            "multi" => local_var_req_builder.query(
3944                &local_var_str
3945                    .into_iter()
3946                    .map(|p| ("route_targets__n".to_owned(), p.to_string()))
3947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3948            ),
3949            _ => local_var_req_builder.query(&[(
3950                "route_targets__n",
3951                &local_var_str
3952                    .into_iter()
3953                    .map(|p| p.to_string())
3954                    .collect::<Vec<String>>()
3955                    .join(",")
3956                    .to_string(),
3957            )]),
3958        };
3959    }
3960    if let Some(ref local_var_str) = sort {
3961        local_var_req_builder =
3962            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
3963    }
3964    if let Some(ref local_var_str) = tags {
3965        local_var_req_builder = match "multi" {
3966            "multi" => local_var_req_builder.query(
3967                &local_var_str
3968                    .into_iter()
3969                    .map(|p| ("tags".to_owned(), p.to_string()))
3970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3971            ),
3972            _ => local_var_req_builder.query(&[(
3973                "tags",
3974                &local_var_str
3975                    .into_iter()
3976                    .map(|p| p.to_string())
3977                    .collect::<Vec<String>>()
3978                    .join(",")
3979                    .to_string(),
3980            )]),
3981        };
3982    }
3983    if let Some(ref local_var_str) = tags__isnull {
3984        local_var_req_builder =
3985            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
3986    }
3987    if let Some(ref local_var_str) = tags__n {
3988        local_var_req_builder = match "multi" {
3989            "multi" => local_var_req_builder.query(
3990                &local_var_str
3991                    .into_iter()
3992                    .map(|p| ("tags__n".to_owned(), p.to_string()))
3993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3994            ),
3995            _ => local_var_req_builder.query(&[(
3996                "tags__n",
3997                &local_var_str
3998                    .into_iter()
3999                    .map(|p| p.to_string())
4000                    .collect::<Vec<String>>()
4001                    .join(",")
4002                    .to_string(),
4003            )]),
4004        };
4005    }
4006    if let Some(ref local_var_str) = teams {
4007        local_var_req_builder = match "multi" {
4008            "multi" => local_var_req_builder.query(
4009                &local_var_str
4010                    .into_iter()
4011                    .map(|p| ("teams".to_owned(), p.to_string()))
4012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4013            ),
4014            _ => local_var_req_builder.query(&[(
4015                "teams",
4016                &local_var_str
4017                    .into_iter()
4018                    .map(|p| p.to_string())
4019                    .collect::<Vec<String>>()
4020                    .join(",")
4021                    .to_string(),
4022            )]),
4023        };
4024    }
4025    if let Some(ref local_var_str) = teams__isnull {
4026        local_var_req_builder =
4027            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
4028    }
4029    if let Some(ref local_var_str) = teams__n {
4030        local_var_req_builder = match "multi" {
4031            "multi" => local_var_req_builder.query(
4032                &local_var_str
4033                    .into_iter()
4034                    .map(|p| ("teams__n".to_owned(), p.to_string()))
4035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4036            ),
4037            _ => local_var_req_builder.query(&[(
4038                "teams__n",
4039                &local_var_str
4040                    .into_iter()
4041                    .map(|p| p.to_string())
4042                    .collect::<Vec<String>>()
4043                    .join(",")
4044                    .to_string(),
4045            )]),
4046        };
4047    }
4048    if let Some(ref local_var_str) = tenant_group {
4049        local_var_req_builder = match "multi" {
4050            "multi" => local_var_req_builder.query(
4051                &local_var_str
4052                    .into_iter()
4053                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
4054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4055            ),
4056            _ => local_var_req_builder.query(&[(
4057                "tenant_group",
4058                &local_var_str
4059                    .into_iter()
4060                    .map(|p| p.to_string())
4061                    .collect::<Vec<String>>()
4062                    .join(",")
4063                    .to_string(),
4064            )]),
4065        };
4066    }
4067    if let Some(ref local_var_str) = tenant_group__isnull {
4068        local_var_req_builder =
4069            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
4070    }
4071    if let Some(ref local_var_str) = tenant_group__n {
4072        local_var_req_builder = match "multi" {
4073            "multi" => local_var_req_builder.query(
4074                &local_var_str
4075                    .into_iter()
4076                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
4077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4078            ),
4079            _ => local_var_req_builder.query(&[(
4080                "tenant_group__n",
4081                &local_var_str
4082                    .into_iter()
4083                    .map(|p| p.to_string())
4084                    .collect::<Vec<String>>()
4085                    .join(",")
4086                    .to_string(),
4087            )]),
4088        };
4089    }
4090    if let Some(ref local_var_str) = virtual_machines {
4091        local_var_req_builder = match "multi" {
4092            "multi" => local_var_req_builder.query(
4093                &local_var_str
4094                    .into_iter()
4095                    .map(|p| ("virtual_machines".to_owned(), p.to_string()))
4096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4097            ),
4098            _ => local_var_req_builder.query(&[(
4099                "virtual_machines",
4100                &local_var_str
4101                    .into_iter()
4102                    .map(|p| p.to_string())
4103                    .collect::<Vec<String>>()
4104                    .join(",")
4105                    .to_string(),
4106            )]),
4107        };
4108    }
4109    if let Some(ref local_var_str) = virtual_machines__isnull {
4110        local_var_req_builder = local_var_req_builder
4111            .query(&[("virtual_machines__isnull", &local_var_str.to_string())]);
4112    }
4113    if let Some(ref local_var_str) = virtual_machines__n {
4114        local_var_req_builder = match "multi" {
4115            "multi" => local_var_req_builder.query(
4116                &local_var_str
4117                    .into_iter()
4118                    .map(|p| ("virtual_machines__n".to_owned(), p.to_string()))
4119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4120            ),
4121            _ => local_var_req_builder.query(&[(
4122                "virtual_machines__n",
4123                &local_var_str
4124                    .into_iter()
4125                    .map(|p| p.to_string())
4126                    .collect::<Vec<String>>()
4127                    .join(",")
4128                    .to_string(),
4129            )]),
4130        };
4131    }
4132    if let Some(ref local_var_str) = vlans {
4133        local_var_req_builder = match "multi" {
4134            "multi" => local_var_req_builder.query(
4135                &local_var_str
4136                    .into_iter()
4137                    .map(|p| ("vlans".to_owned(), p.to_string()))
4138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4139            ),
4140            _ => local_var_req_builder.query(&[(
4141                "vlans",
4142                &local_var_str
4143                    .into_iter()
4144                    .map(|p| p.to_string())
4145                    .collect::<Vec<String>>()
4146                    .join(",")
4147                    .to_string(),
4148            )]),
4149        };
4150    }
4151    if let Some(ref local_var_str) = vlans__isnull {
4152        local_var_req_builder =
4153            local_var_req_builder.query(&[("vlans__isnull", &local_var_str.to_string())]);
4154    }
4155    if let Some(ref local_var_str) = vlans__n {
4156        local_var_req_builder = match "multi" {
4157            "multi" => local_var_req_builder.query(
4158                &local_var_str
4159                    .into_iter()
4160                    .map(|p| ("vlans__n".to_owned(), p.to_string()))
4161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4162            ),
4163            _ => local_var_req_builder.query(&[(
4164                "vlans__n",
4165                &local_var_str
4166                    .into_iter()
4167                    .map(|p| p.to_string())
4168                    .collect::<Vec<String>>()
4169                    .join(",")
4170                    .to_string(),
4171            )]),
4172        };
4173    }
4174    if let Some(ref local_var_str) = vrfs {
4175        local_var_req_builder = match "multi" {
4176            "multi" => local_var_req_builder.query(
4177                &local_var_str
4178                    .into_iter()
4179                    .map(|p| ("vrfs".to_owned(), p.to_string()))
4180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4181            ),
4182            _ => local_var_req_builder.query(&[(
4183                "vrfs",
4184                &local_var_str
4185                    .into_iter()
4186                    .map(|p| p.to_string())
4187                    .collect::<Vec<String>>()
4188                    .join(",")
4189                    .to_string(),
4190            )]),
4191        };
4192    }
4193    if let Some(ref local_var_str) = vrfs__isnull {
4194        local_var_req_builder =
4195            local_var_req_builder.query(&[("vrfs__isnull", &local_var_str.to_string())]);
4196    }
4197    if let Some(ref local_var_str) = vrfs__n {
4198        local_var_req_builder = match "multi" {
4199            "multi" => local_var_req_builder.query(
4200                &local_var_str
4201                    .into_iter()
4202                    .map(|p| ("vrfs__n".to_owned(), p.to_string()))
4203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4204            ),
4205            _ => local_var_req_builder.query(&[(
4206                "vrfs__n",
4207                &local_var_str
4208                    .into_iter()
4209                    .map(|p| p.to_string())
4210                    .collect::<Vec<String>>()
4211                    .join(",")
4212                    .to_string(),
4213            )]),
4214        };
4215    }
4216    if let Some(ref local_var_str) = depth {
4217        local_var_req_builder =
4218            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4219    }
4220    if let Some(ref local_var_str) = exclude_m2m {
4221        local_var_req_builder =
4222            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4223    }
4224    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4225        local_var_req_builder =
4226            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4227    }
4228    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4229        let local_var_key = local_var_apikey.key.clone();
4230        let local_var_value = match local_var_apikey.prefix {
4231            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4232            None => local_var_key,
4233        };
4234        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4235    };
4236
4237    let local_var_req = local_var_req_builder.build()?;
4238    let local_var_resp = local_var_client.execute(local_var_req).await?;
4239
4240    let local_var_status = local_var_resp.status();
4241    let local_var_content = local_var_resp.text().await?;
4242
4243    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4244        serde_json::from_str(&local_var_content).map_err(Error::from)
4245    } else {
4246        let local_var_entity: Option<TenancyTenantsListError> =
4247            serde_json::from_str(&local_var_content).ok();
4248        let local_var_error = ResponseContent {
4249            status: local_var_status,
4250            content: local_var_content,
4251            entity: local_var_entity,
4252        };
4253        Err(Error::ResponseError(local_var_error))
4254    }
4255}
4256
4257/// API methods for returning or creating notes on an object.
4258pub async fn tenancy_tenants_notes_create(
4259    configuration: &configuration::Configuration,
4260    id: &str,
4261    note_input_request: crate::models::NoteInputRequest,
4262    format: Option<&str>,
4263) -> Result<crate::models::Note, Error<TenancyTenantsNotesCreateError>> {
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        "{}/tenancy/tenants/{id}/notes/",
4270        local_var_configuration.base_path,
4271        id = crate::apis::urlencode(id)
4272    );
4273    let mut local_var_req_builder =
4274        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4275
4276    if let Some(ref local_var_str) = format {
4277        local_var_req_builder =
4278            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4279    }
4280    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4281        local_var_req_builder =
4282            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4283    }
4284    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4285        let local_var_key = local_var_apikey.key.clone();
4286        let local_var_value = match local_var_apikey.prefix {
4287            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4288            None => local_var_key,
4289        };
4290        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4291    };
4292    local_var_req_builder = local_var_req_builder.json(&note_input_request);
4293
4294    let local_var_req = local_var_req_builder.build()?;
4295    let local_var_resp = local_var_client.execute(local_var_req).await?;
4296
4297    let local_var_status = local_var_resp.status();
4298    let local_var_content = local_var_resp.text().await?;
4299
4300    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4301        serde_json::from_str(&local_var_content).map_err(Error::from)
4302    } else {
4303        let local_var_entity: Option<TenancyTenantsNotesCreateError> =
4304            serde_json::from_str(&local_var_content).ok();
4305        let local_var_error = ResponseContent {
4306            status: local_var_status,
4307            content: local_var_content,
4308            entity: local_var_entity,
4309        };
4310        Err(Error::ResponseError(local_var_error))
4311    }
4312}
4313
4314/// API methods for returning or creating notes on an object.
4315pub async fn tenancy_tenants_notes_list(
4316    configuration: &configuration::Configuration,
4317    id: &str,
4318    format: Option<&str>,
4319    limit: Option<i32>,
4320    offset: Option<i32>,
4321    depth: Option<i32>,
4322    exclude_m2m: Option<bool>,
4323) -> Result<crate::models::PaginatedNoteList, Error<TenancyTenantsNotesListError>> {
4324    let local_var_configuration = configuration;
4325
4326    let local_var_client = &local_var_configuration.client;
4327
4328    let local_var_uri_str = format!(
4329        "{}/tenancy/tenants/{id}/notes/",
4330        local_var_configuration.base_path,
4331        id = crate::apis::urlencode(id)
4332    );
4333    let mut local_var_req_builder =
4334        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4335
4336    if let Some(ref local_var_str) = format {
4337        local_var_req_builder =
4338            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4339    }
4340    if let Some(ref local_var_str) = limit {
4341        local_var_req_builder =
4342            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4343    }
4344    if let Some(ref local_var_str) = offset {
4345        local_var_req_builder =
4346            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4347    }
4348    if let Some(ref local_var_str) = depth {
4349        local_var_req_builder =
4350            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4351    }
4352    if let Some(ref local_var_str) = exclude_m2m {
4353        local_var_req_builder =
4354            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4355    }
4356    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4357        local_var_req_builder =
4358            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4359    }
4360    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4361        let local_var_key = local_var_apikey.key.clone();
4362        let local_var_value = match local_var_apikey.prefix {
4363            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4364            None => local_var_key,
4365        };
4366        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4367    };
4368
4369    let local_var_req = local_var_req_builder.build()?;
4370    let local_var_resp = local_var_client.execute(local_var_req).await?;
4371
4372    let local_var_status = local_var_resp.status();
4373    let local_var_content = local_var_resp.text().await?;
4374
4375    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4376        serde_json::from_str(&local_var_content).map_err(Error::from)
4377    } else {
4378        let local_var_entity: Option<TenancyTenantsNotesListError> =
4379            serde_json::from_str(&local_var_content).ok();
4380        let local_var_error = ResponseContent {
4381            status: local_var_status,
4382            content: local_var_content,
4383            entity: local_var_entity,
4384        };
4385        Err(Error::ResponseError(local_var_error))
4386    }
4387}
4388
4389/// Partial update a tenant object.
4390pub async fn tenancy_tenants_partial_update(
4391    configuration: &configuration::Configuration,
4392    id: &str,
4393    format: Option<&str>,
4394    patched_tenant_request: Option<crate::models::PatchedTenantRequest>,
4395) -> Result<crate::models::Tenant, Error<TenancyTenantsPartialUpdateError>> {
4396    let local_var_configuration = configuration;
4397
4398    let local_var_client = &local_var_configuration.client;
4399
4400    let local_var_uri_str = format!(
4401        "{}/tenancy/tenants/{id}/",
4402        local_var_configuration.base_path,
4403        id = crate::apis::urlencode(id)
4404    );
4405    let mut local_var_req_builder =
4406        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4407
4408    if let Some(ref local_var_str) = format {
4409        local_var_req_builder =
4410            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4411    }
4412    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4413        local_var_req_builder =
4414            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4415    }
4416    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4417        let local_var_key = local_var_apikey.key.clone();
4418        let local_var_value = match local_var_apikey.prefix {
4419            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4420            None => local_var_key,
4421        };
4422        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4423    };
4424    local_var_req_builder = local_var_req_builder.json(&patched_tenant_request);
4425
4426    let local_var_req = local_var_req_builder.build()?;
4427    let local_var_resp = local_var_client.execute(local_var_req).await?;
4428
4429    let local_var_status = local_var_resp.status();
4430    let local_var_content = local_var_resp.text().await?;
4431
4432    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4433        serde_json::from_str(&local_var_content).map_err(Error::from)
4434    } else {
4435        let local_var_entity: Option<TenancyTenantsPartialUpdateError> =
4436            serde_json::from_str(&local_var_content).ok();
4437        let local_var_error = ResponseContent {
4438            status: local_var_status,
4439            content: local_var_content,
4440            entity: local_var_entity,
4441        };
4442        Err(Error::ResponseError(local_var_error))
4443    }
4444}
4445
4446/// Retrieve a tenant object.
4447pub async fn tenancy_tenants_retrieve(
4448    configuration: &configuration::Configuration,
4449    id: &str,
4450    format: Option<&str>,
4451    depth: Option<i32>,
4452    exclude_m2m: Option<bool>,
4453) -> Result<crate::models::Tenant, Error<TenancyTenantsRetrieveError>> {
4454    let local_var_configuration = configuration;
4455
4456    let local_var_client = &local_var_configuration.client;
4457
4458    let local_var_uri_str = format!(
4459        "{}/tenancy/tenants/{id}/",
4460        local_var_configuration.base_path,
4461        id = crate::apis::urlencode(id)
4462    );
4463    let mut local_var_req_builder =
4464        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4465
4466    if let Some(ref local_var_str) = format {
4467        local_var_req_builder =
4468            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4469    }
4470    if let Some(ref local_var_str) = depth {
4471        local_var_req_builder =
4472            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4473    }
4474    if let Some(ref local_var_str) = exclude_m2m {
4475        local_var_req_builder =
4476            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4477    }
4478    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4479        local_var_req_builder =
4480            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4481    }
4482    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4483        let local_var_key = local_var_apikey.key.clone();
4484        let local_var_value = match local_var_apikey.prefix {
4485            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4486            None => local_var_key,
4487        };
4488        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4489    };
4490
4491    let local_var_req = local_var_req_builder.build()?;
4492    let local_var_resp = local_var_client.execute(local_var_req).await?;
4493
4494    let local_var_status = local_var_resp.status();
4495    let local_var_content = local_var_resp.text().await?;
4496
4497    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4498        serde_json::from_str(&local_var_content).map_err(Error::from)
4499    } else {
4500        let local_var_entity: Option<TenancyTenantsRetrieveError> =
4501            serde_json::from_str(&local_var_content).ok();
4502        let local_var_error = ResponseContent {
4503            status: local_var_status,
4504            content: local_var_content,
4505            entity: local_var_entity,
4506        };
4507        Err(Error::ResponseError(local_var_error))
4508    }
4509}
4510
4511/// Update a tenant object.
4512pub async fn tenancy_tenants_update(
4513    configuration: &configuration::Configuration,
4514    id: &str,
4515    tenant_request: crate::models::TenantRequest,
4516    format: Option<&str>,
4517) -> Result<crate::models::Tenant, Error<TenancyTenantsUpdateError>> {
4518    let local_var_configuration = configuration;
4519
4520    let local_var_client = &local_var_configuration.client;
4521
4522    let local_var_uri_str = format!(
4523        "{}/tenancy/tenants/{id}/",
4524        local_var_configuration.base_path,
4525        id = crate::apis::urlencode(id)
4526    );
4527    let mut local_var_req_builder =
4528        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4529
4530    if let Some(ref local_var_str) = format {
4531        local_var_req_builder =
4532            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4533    }
4534    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4535        local_var_req_builder =
4536            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4537    }
4538    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4539        let local_var_key = local_var_apikey.key.clone();
4540        let local_var_value = match local_var_apikey.prefix {
4541            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4542            None => local_var_key,
4543        };
4544        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4545    };
4546    local_var_req_builder = local_var_req_builder.json(&tenant_request);
4547
4548    let local_var_req = local_var_req_builder.build()?;
4549    let local_var_resp = local_var_client.execute(local_var_req).await?;
4550
4551    let local_var_status = local_var_resp.status();
4552    let local_var_content = local_var_resp.text().await?;
4553
4554    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4555        serde_json::from_str(&local_var_content).map_err(Error::from)
4556    } else {
4557        let local_var_entity: Option<TenancyTenantsUpdateError> =
4558            serde_json::from_str(&local_var_content).ok();
4559        let local_var_error = ResponseContent {
4560            status: local_var_status,
4561            content: local_var_content,
4562            entity: local_var_entity,
4563        };
4564        Err(Error::ResponseError(local_var_error))
4565    }
4566}
nautobot_openapi/apis/tenancy_api.rs

nautobot_openapi/apis/
tenancy_api.rs
