netbox_openapi/apis/
tenancy_api.rs

1/*
2 * NetBox REST API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 4.4.2-Docker-3.4.1 (4.4)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`tenancy_contact_assignments_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum TenancyContactAssignmentsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`tenancy_contact_assignments_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum TenancyContactAssignmentsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`tenancy_contact_assignments_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum TenancyContactAssignmentsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`tenancy_contact_assignments_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum TenancyContactAssignmentsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`tenancy_contact_assignments_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum TenancyContactAssignmentsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`tenancy_contact_assignments_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum TenancyContactAssignmentsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`tenancy_contact_assignments_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum TenancyContactAssignmentsPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`tenancy_contact_assignments_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum TenancyContactAssignmentsRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`tenancy_contact_assignments_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum TenancyContactAssignmentsUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`tenancy_contact_groups_bulk_destroy`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum TenancyContactGroupsBulkDestroyError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`tenancy_contact_groups_bulk_partial_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum TenancyContactGroupsBulkPartialUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`tenancy_contact_groups_bulk_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum TenancyContactGroupsBulkUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`tenancy_contact_groups_create`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum TenancyContactGroupsCreateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`tenancy_contact_groups_destroy`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum TenancyContactGroupsDestroyError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`tenancy_contact_groups_list`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum TenancyContactGroupsListError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`tenancy_contact_groups_partial_update`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum TenancyContactGroupsPartialUpdateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`tenancy_contact_groups_retrieve`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum TenancyContactGroupsRetrieveError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`tenancy_contact_groups_update`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum TenancyContactGroupsUpdateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`tenancy_contact_roles_bulk_destroy`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum TenancyContactRolesBulkDestroyError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`tenancy_contact_roles_bulk_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum TenancyContactRolesBulkPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`tenancy_contact_roles_bulk_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum TenancyContactRolesBulkUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`tenancy_contact_roles_create`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum TenancyContactRolesCreateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`tenancy_contact_roles_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum TenancyContactRolesDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`tenancy_contact_roles_list`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum TenancyContactRolesListError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`tenancy_contact_roles_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum TenancyContactRolesPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`tenancy_contact_roles_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum TenancyContactRolesRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`tenancy_contact_roles_update`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum TenancyContactRolesUpdateError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`tenancy_contacts_bulk_destroy`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum TenancyContactsBulkDestroyError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`tenancy_contacts_bulk_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum TenancyContactsBulkPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`tenancy_contacts_bulk_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum TenancyContactsBulkUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`tenancy_contacts_create`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum TenancyContactsCreateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`tenancy_contacts_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum TenancyContactsDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`tenancy_contacts_list`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum TenancyContactsListError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`tenancy_contacts_partial_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum TenancyContactsPartialUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`tenancy_contacts_retrieve`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum TenancyContactsRetrieveError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`tenancy_contacts_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum TenancyContactsUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`tenancy_tenant_groups_bulk_destroy`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum TenancyTenantGroupsBulkDestroyError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`tenancy_tenant_groups_bulk_partial_update`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum TenancyTenantGroupsBulkPartialUpdateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`tenancy_tenant_groups_bulk_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum TenancyTenantGroupsBulkUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`tenancy_tenant_groups_create`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum TenancyTenantGroupsCreateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`tenancy_tenant_groups_destroy`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum TenancyTenantGroupsDestroyError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`tenancy_tenant_groups_list`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum TenancyTenantGroupsListError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`tenancy_tenant_groups_partial_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum TenancyTenantGroupsPartialUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`tenancy_tenant_groups_retrieve`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum TenancyTenantGroupsRetrieveError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`tenancy_tenant_groups_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum TenancyTenantGroupsUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`tenancy_tenants_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum TenancyTenantsBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`tenancy_tenants_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum TenancyTenantsBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`tenancy_tenants_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum TenancyTenantsBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`tenancy_tenants_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum TenancyTenantsCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`tenancy_tenants_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum TenancyTenantsDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`tenancy_tenants_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum TenancyTenantsListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`tenancy_tenants_partial_update`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum TenancyTenantsPartialUpdateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`tenancy_tenants_retrieve`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum TenancyTenantsRetrieveError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`tenancy_tenants_update`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum TenancyTenantsUpdateError {
391    UnknownValue(serde_json::Value),
392}
393
394/// Delete a list of contact assignment objects.
395pub async fn tenancy_contact_assignments_bulk_destroy(
396    configuration: &configuration::Configuration,
397    contact_assignment_request: Vec<crate::models::ContactAssignmentRequest>,
398) -> Result<(), Error<TenancyContactAssignmentsBulkDestroyError>> {
399    let local_var_configuration = configuration;
400
401    let local_var_client = &local_var_configuration.client;
402
403    let local_var_uri_str = format!(
404        "{}/api/tenancy/contact-assignments/",
405        local_var_configuration.base_path
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_user_agent) = local_var_configuration.user_agent {
411        local_var_req_builder =
412            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
413    }
414    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
415        let local_var_key = local_var_apikey.key.clone();
416        let local_var_value = match local_var_apikey.prefix {
417            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
418            None => local_var_key,
419        };
420        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
421    };
422    local_var_req_builder = local_var_req_builder.json(&contact_assignment_request);
423
424    let local_var_req = local_var_req_builder.build()?;
425    let local_var_resp = local_var_client.execute(local_var_req).await?;
426
427    let local_var_status = local_var_resp.status();
428    let local_var_content = local_var_resp.text().await?;
429
430    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
431        Ok(())
432    } else {
433        let local_var_entity: Option<TenancyContactAssignmentsBulkDestroyError> =
434            serde_json::from_str(&local_var_content).ok();
435        let local_var_error = ResponseContent {
436            status: local_var_status,
437            content: local_var_content,
438            entity: local_var_entity,
439        };
440        Err(Error::ResponseError(local_var_error))
441    }
442}
443
444/// Patch a list of contact assignment objects.
445pub async fn tenancy_contact_assignments_bulk_partial_update(
446    configuration: &configuration::Configuration,
447    contact_assignment_request: Vec<crate::models::ContactAssignmentRequest>,
448) -> Result<
449    Vec<crate::models::ContactAssignment>,
450    Error<TenancyContactAssignmentsBulkPartialUpdateError>,
451> {
452    let local_var_configuration = configuration;
453
454    let local_var_client = &local_var_configuration.client;
455
456    let local_var_uri_str = format!(
457        "{}/api/tenancy/contact-assignments/",
458        local_var_configuration.base_path
459    );
460    let mut local_var_req_builder =
461        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
462
463    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
464        local_var_req_builder =
465            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
466    }
467    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
468        let local_var_key = local_var_apikey.key.clone();
469        let local_var_value = match local_var_apikey.prefix {
470            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
471            None => local_var_key,
472        };
473        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
474    };
475    local_var_req_builder = local_var_req_builder.json(&contact_assignment_request);
476
477    let local_var_req = local_var_req_builder.build()?;
478    let local_var_resp = local_var_client.execute(local_var_req).await?;
479
480    let local_var_status = local_var_resp.status();
481    let local_var_content = local_var_resp.text().await?;
482
483    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
484        serde_json::from_str(&local_var_content).map_err(Error::from)
485    } else {
486        let local_var_entity: Option<TenancyContactAssignmentsBulkPartialUpdateError> =
487            serde_json::from_str(&local_var_content).ok();
488        let local_var_error = ResponseContent {
489            status: local_var_status,
490            content: local_var_content,
491            entity: local_var_entity,
492        };
493        Err(Error::ResponseError(local_var_error))
494    }
495}
496
497/// Put a list of contact assignment objects.
498pub async fn tenancy_contact_assignments_bulk_update(
499    configuration: &configuration::Configuration,
500    contact_assignment_request: Vec<crate::models::ContactAssignmentRequest>,
501) -> Result<Vec<crate::models::ContactAssignment>, Error<TenancyContactAssignmentsBulkUpdateError>>
502{
503    let local_var_configuration = configuration;
504
505    let local_var_client = &local_var_configuration.client;
506
507    let local_var_uri_str = format!(
508        "{}/api/tenancy/contact-assignments/",
509        local_var_configuration.base_path
510    );
511    let mut local_var_req_builder =
512        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
513
514    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
515        local_var_req_builder =
516            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
517    }
518    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
519        let local_var_key = local_var_apikey.key.clone();
520        let local_var_value = match local_var_apikey.prefix {
521            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
522            None => local_var_key,
523        };
524        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
525    };
526    local_var_req_builder = local_var_req_builder.json(&contact_assignment_request);
527
528    let local_var_req = local_var_req_builder.build()?;
529    let local_var_resp = local_var_client.execute(local_var_req).await?;
530
531    let local_var_status = local_var_resp.status();
532    let local_var_content = local_var_resp.text().await?;
533
534    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
535        serde_json::from_str(&local_var_content).map_err(Error::from)
536    } else {
537        let local_var_entity: Option<TenancyContactAssignmentsBulkUpdateError> =
538            serde_json::from_str(&local_var_content).ok();
539        let local_var_error = ResponseContent {
540            status: local_var_status,
541            content: local_var_content,
542            entity: local_var_entity,
543        };
544        Err(Error::ResponseError(local_var_error))
545    }
546}
547
548/// Post a list of contact assignment objects.
549pub async fn tenancy_contact_assignments_create(
550    configuration: &configuration::Configuration,
551    writable_contact_assignment_request: crate::models::WritableContactAssignmentRequest,
552) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsCreateError>> {
553    let local_var_configuration = configuration;
554
555    let local_var_client = &local_var_configuration.client;
556
557    let local_var_uri_str = format!(
558        "{}/api/tenancy/contact-assignments/",
559        local_var_configuration.base_path
560    );
561    let mut local_var_req_builder =
562        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
563
564    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
565        local_var_req_builder =
566            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
567    }
568    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
569        let local_var_key = local_var_apikey.key.clone();
570        let local_var_value = match local_var_apikey.prefix {
571            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
572            None => local_var_key,
573        };
574        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
575    };
576    local_var_req_builder = local_var_req_builder.json(&writable_contact_assignment_request);
577
578    let local_var_req = local_var_req_builder.build()?;
579    let local_var_resp = local_var_client.execute(local_var_req).await?;
580
581    let local_var_status = local_var_resp.status();
582    let local_var_content = local_var_resp.text().await?;
583
584    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
585        serde_json::from_str(&local_var_content).map_err(Error::from)
586    } else {
587        let local_var_entity: Option<TenancyContactAssignmentsCreateError> =
588            serde_json::from_str(&local_var_content).ok();
589        let local_var_error = ResponseContent {
590            status: local_var_status,
591            content: local_var_content,
592            entity: local_var_entity,
593        };
594        Err(Error::ResponseError(local_var_error))
595    }
596}
597
598/// Delete a contact assignment object.
599pub async fn tenancy_contact_assignments_destroy(
600    configuration: &configuration::Configuration,
601    id: i32,
602) -> Result<(), Error<TenancyContactAssignmentsDestroyError>> {
603    let local_var_configuration = configuration;
604
605    let local_var_client = &local_var_configuration.client;
606
607    let local_var_uri_str = format!(
608        "{}/api/tenancy/contact-assignments/{id}/",
609        local_var_configuration.base_path,
610        id = id
611    );
612    let mut local_var_req_builder =
613        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
614
615    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
616        local_var_req_builder =
617            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
618    }
619    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
620        let local_var_key = local_var_apikey.key.clone();
621        let local_var_value = match local_var_apikey.prefix {
622            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
623            None => local_var_key,
624        };
625        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
626    };
627
628    let local_var_req = local_var_req_builder.build()?;
629    let local_var_resp = local_var_client.execute(local_var_req).await?;
630
631    let local_var_status = local_var_resp.status();
632    let local_var_content = local_var_resp.text().await?;
633
634    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
635        Ok(())
636    } else {
637        let local_var_entity: Option<TenancyContactAssignmentsDestroyError> =
638            serde_json::from_str(&local_var_content).ok();
639        let local_var_error = ResponseContent {
640            status: local_var_status,
641            content: local_var_content,
642            entity: local_var_entity,
643        };
644        Err(Error::ResponseError(local_var_error))
645    }
646}
647
648/// Get a list of contact assignment objects.
649pub async fn tenancy_contact_assignments_list(
650    configuration: &configuration::Configuration,
651    contact_id: Option<Vec<i32>>,
652    contact_id__n: Option<Vec<i32>>,
653    created: Option<Vec<String>>,
654    created__empty: Option<Vec<String>>,
655    created__gt: Option<Vec<String>>,
656    created__gte: Option<Vec<String>>,
657    created__lt: Option<Vec<String>>,
658    created__lte: Option<Vec<String>>,
659    created__n: Option<Vec<String>>,
660    created_by_request: Option<&str>,
661    group: Option<Vec<String>>,
662    group__n: Option<Vec<String>>,
663    group_id: Option<Vec<String>>,
664    group_id__n: Option<Vec<String>>,
665    id: Option<Vec<i32>>,
666    id__empty: Option<bool>,
667    id__gt: Option<Vec<i32>>,
668    id__gte: Option<Vec<i32>>,
669    id__lt: Option<Vec<i32>>,
670    id__lte: Option<Vec<i32>>,
671    id__n: Option<Vec<i32>>,
672    last_updated: Option<Vec<String>>,
673    last_updated__empty: Option<Vec<String>>,
674    last_updated__gt: Option<Vec<String>>,
675    last_updated__gte: Option<Vec<String>>,
676    last_updated__lt: Option<Vec<String>>,
677    last_updated__lte: Option<Vec<String>>,
678    last_updated__n: Option<Vec<String>>,
679    limit: Option<i32>,
680    modified_by_request: Option<&str>,
681    object_id: Option<Vec<i32>>,
682    object_id__empty: Option<bool>,
683    object_id__gt: Option<Vec<i32>>,
684    object_id__gte: Option<Vec<i32>>,
685    object_id__lt: Option<Vec<i32>>,
686    object_id__lte: Option<Vec<i32>>,
687    object_id__n: Option<Vec<i32>>,
688    object_type: Option<&str>,
689    object_type__n: Option<&str>,
690    object_type_id: Option<i32>,
691    object_type_id__n: Option<i32>,
692    offset: Option<i32>,
693    ordering: Option<&str>,
694    priority: Option<&str>,
695    q: Option<&str>,
696    role: Option<Vec<String>>,
697    role__n: Option<Vec<String>>,
698    role_id: Option<Vec<i32>>,
699    role_id__n: Option<Vec<i32>>,
700    tag: Option<Vec<String>>,
701    tag__n: Option<Vec<String>>,
702    tag_id: Option<Vec<i32>>,
703    tag_id__n: Option<Vec<i32>>,
704    updated_by_request: Option<&str>,
705) -> Result<crate::models::PaginatedContactAssignmentList, Error<TenancyContactAssignmentsListError>>
706{
707    let local_var_configuration = configuration;
708
709    let local_var_client = &local_var_configuration.client;
710
711    let local_var_uri_str = format!(
712        "{}/api/tenancy/contact-assignments/",
713        local_var_configuration.base_path
714    );
715    let mut local_var_req_builder =
716        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
717
718    if let Some(ref local_var_str) = contact_id {
719        local_var_req_builder = match "multi" {
720            "multi" => local_var_req_builder.query(
721                &local_var_str
722                    .into_iter()
723                    .map(|p| ("contact_id".to_owned(), p.to_string()))
724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
725            ),
726            _ => local_var_req_builder.query(&[(
727                "contact_id",
728                &local_var_str
729                    .into_iter()
730                    .map(|p| p.to_string())
731                    .collect::<Vec<String>>()
732                    .join(",")
733                    .to_string(),
734            )]),
735        };
736    }
737    if let Some(ref local_var_str) = contact_id__n {
738        local_var_req_builder = match "multi" {
739            "multi" => local_var_req_builder.query(
740                &local_var_str
741                    .into_iter()
742                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
744            ),
745            _ => local_var_req_builder.query(&[(
746                "contact_id__n",
747                &local_var_str
748                    .into_iter()
749                    .map(|p| p.to_string())
750                    .collect::<Vec<String>>()
751                    .join(",")
752                    .to_string(),
753            )]),
754        };
755    }
756    if let Some(ref local_var_str) = created {
757        local_var_req_builder = match "multi" {
758            "multi" => local_var_req_builder.query(
759                &local_var_str
760                    .into_iter()
761                    .map(|p| ("created".to_owned(), p.to_string()))
762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
763            ),
764            _ => local_var_req_builder.query(&[(
765                "created",
766                &local_var_str
767                    .into_iter()
768                    .map(|p| p.to_string())
769                    .collect::<Vec<String>>()
770                    .join(",")
771                    .to_string(),
772            )]),
773        };
774    }
775    if let Some(ref local_var_str) = created__empty {
776        local_var_req_builder = match "multi" {
777            "multi" => local_var_req_builder.query(
778                &local_var_str
779                    .into_iter()
780                    .map(|p| ("created__empty".to_owned(), p.to_string()))
781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
782            ),
783            _ => local_var_req_builder.query(&[(
784                "created__empty",
785                &local_var_str
786                    .into_iter()
787                    .map(|p| p.to_string())
788                    .collect::<Vec<String>>()
789                    .join(",")
790                    .to_string(),
791            )]),
792        };
793    }
794    if let Some(ref local_var_str) = created__gt {
795        local_var_req_builder = match "multi" {
796            "multi" => local_var_req_builder.query(
797                &local_var_str
798                    .into_iter()
799                    .map(|p| ("created__gt".to_owned(), p.to_string()))
800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
801            ),
802            _ => local_var_req_builder.query(&[(
803                "created__gt",
804                &local_var_str
805                    .into_iter()
806                    .map(|p| p.to_string())
807                    .collect::<Vec<String>>()
808                    .join(",")
809                    .to_string(),
810            )]),
811        };
812    }
813    if let Some(ref local_var_str) = created__gte {
814        local_var_req_builder = match "multi" {
815            "multi" => local_var_req_builder.query(
816                &local_var_str
817                    .into_iter()
818                    .map(|p| ("created__gte".to_owned(), p.to_string()))
819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
820            ),
821            _ => local_var_req_builder.query(&[(
822                "created__gte",
823                &local_var_str
824                    .into_iter()
825                    .map(|p| p.to_string())
826                    .collect::<Vec<String>>()
827                    .join(",")
828                    .to_string(),
829            )]),
830        };
831    }
832    if let Some(ref local_var_str) = created__lt {
833        local_var_req_builder = match "multi" {
834            "multi" => local_var_req_builder.query(
835                &local_var_str
836                    .into_iter()
837                    .map(|p| ("created__lt".to_owned(), p.to_string()))
838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
839            ),
840            _ => local_var_req_builder.query(&[(
841                "created__lt",
842                &local_var_str
843                    .into_iter()
844                    .map(|p| p.to_string())
845                    .collect::<Vec<String>>()
846                    .join(",")
847                    .to_string(),
848            )]),
849        };
850    }
851    if let Some(ref local_var_str) = created__lte {
852        local_var_req_builder = match "multi" {
853            "multi" => local_var_req_builder.query(
854                &local_var_str
855                    .into_iter()
856                    .map(|p| ("created__lte".to_owned(), p.to_string()))
857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
858            ),
859            _ => local_var_req_builder.query(&[(
860                "created__lte",
861                &local_var_str
862                    .into_iter()
863                    .map(|p| p.to_string())
864                    .collect::<Vec<String>>()
865                    .join(",")
866                    .to_string(),
867            )]),
868        };
869    }
870    if let Some(ref local_var_str) = created__n {
871        local_var_req_builder = match "multi" {
872            "multi" => local_var_req_builder.query(
873                &local_var_str
874                    .into_iter()
875                    .map(|p| ("created__n".to_owned(), p.to_string()))
876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
877            ),
878            _ => local_var_req_builder.query(&[(
879                "created__n",
880                &local_var_str
881                    .into_iter()
882                    .map(|p| p.to_string())
883                    .collect::<Vec<String>>()
884                    .join(",")
885                    .to_string(),
886            )]),
887        };
888    }
889    if let Some(ref local_var_str) = created_by_request {
890        local_var_req_builder =
891            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
892    }
893    if let Some(ref local_var_str) = group {
894        local_var_req_builder = match "multi" {
895            "multi" => local_var_req_builder.query(
896                &local_var_str
897                    .into_iter()
898                    .map(|p| ("group".to_owned(), p.to_string()))
899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
900            ),
901            _ => local_var_req_builder.query(&[(
902                "group",
903                &local_var_str
904                    .into_iter()
905                    .map(|p| p.to_string())
906                    .collect::<Vec<String>>()
907                    .join(",")
908                    .to_string(),
909            )]),
910        };
911    }
912    if let Some(ref local_var_str) = group__n {
913        local_var_req_builder = match "multi" {
914            "multi" => local_var_req_builder.query(
915                &local_var_str
916                    .into_iter()
917                    .map(|p| ("group__n".to_owned(), p.to_string()))
918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
919            ),
920            _ => local_var_req_builder.query(&[(
921                "group__n",
922                &local_var_str
923                    .into_iter()
924                    .map(|p| p.to_string())
925                    .collect::<Vec<String>>()
926                    .join(",")
927                    .to_string(),
928            )]),
929        };
930    }
931    if let Some(ref local_var_str) = group_id {
932        local_var_req_builder = match "multi" {
933            "multi" => local_var_req_builder.query(
934                &local_var_str
935                    .into_iter()
936                    .map(|p| ("group_id".to_owned(), p.to_string()))
937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
938            ),
939            _ => local_var_req_builder.query(&[(
940                "group_id",
941                &local_var_str
942                    .into_iter()
943                    .map(|p| p.to_string())
944                    .collect::<Vec<String>>()
945                    .join(",")
946                    .to_string(),
947            )]),
948        };
949    }
950    if let Some(ref local_var_str) = group_id__n {
951        local_var_req_builder = match "multi" {
952            "multi" => local_var_req_builder.query(
953                &local_var_str
954                    .into_iter()
955                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
957            ),
958            _ => local_var_req_builder.query(&[(
959                "group_id__n",
960                &local_var_str
961                    .into_iter()
962                    .map(|p| p.to_string())
963                    .collect::<Vec<String>>()
964                    .join(",")
965                    .to_string(),
966            )]),
967        };
968    }
969    if let Some(ref local_var_str) = id {
970        local_var_req_builder = match "multi" {
971            "multi" => local_var_req_builder.query(
972                &local_var_str
973                    .into_iter()
974                    .map(|p| ("id".to_owned(), p.to_string()))
975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
976            ),
977            _ => local_var_req_builder.query(&[(
978                "id",
979                &local_var_str
980                    .into_iter()
981                    .map(|p| p.to_string())
982                    .collect::<Vec<String>>()
983                    .join(",")
984                    .to_string(),
985            )]),
986        };
987    }
988    if let Some(ref local_var_str) = id__empty {
989        local_var_req_builder =
990            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
991    }
992    if let Some(ref local_var_str) = id__gt {
993        local_var_req_builder = match "multi" {
994            "multi" => local_var_req_builder.query(
995                &local_var_str
996                    .into_iter()
997                    .map(|p| ("id__gt".to_owned(), p.to_string()))
998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
999            ),
1000            _ => local_var_req_builder.query(&[(
1001                "id__gt",
1002                &local_var_str
1003                    .into_iter()
1004                    .map(|p| p.to_string())
1005                    .collect::<Vec<String>>()
1006                    .join(",")
1007                    .to_string(),
1008            )]),
1009        };
1010    }
1011    if let Some(ref local_var_str) = id__gte {
1012        local_var_req_builder = match "multi" {
1013            "multi" => local_var_req_builder.query(
1014                &local_var_str
1015                    .into_iter()
1016                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1018            ),
1019            _ => local_var_req_builder.query(&[(
1020                "id__gte",
1021                &local_var_str
1022                    .into_iter()
1023                    .map(|p| p.to_string())
1024                    .collect::<Vec<String>>()
1025                    .join(",")
1026                    .to_string(),
1027            )]),
1028        };
1029    }
1030    if let Some(ref local_var_str) = id__lt {
1031        local_var_req_builder = match "multi" {
1032            "multi" => local_var_req_builder.query(
1033                &local_var_str
1034                    .into_iter()
1035                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1037            ),
1038            _ => local_var_req_builder.query(&[(
1039                "id__lt",
1040                &local_var_str
1041                    .into_iter()
1042                    .map(|p| p.to_string())
1043                    .collect::<Vec<String>>()
1044                    .join(",")
1045                    .to_string(),
1046            )]),
1047        };
1048    }
1049    if let Some(ref local_var_str) = id__lte {
1050        local_var_req_builder = match "multi" {
1051            "multi" => local_var_req_builder.query(
1052                &local_var_str
1053                    .into_iter()
1054                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1056            ),
1057            _ => local_var_req_builder.query(&[(
1058                "id__lte",
1059                &local_var_str
1060                    .into_iter()
1061                    .map(|p| p.to_string())
1062                    .collect::<Vec<String>>()
1063                    .join(",")
1064                    .to_string(),
1065            )]),
1066        };
1067    }
1068    if let Some(ref local_var_str) = id__n {
1069        local_var_req_builder = match "multi" {
1070            "multi" => local_var_req_builder.query(
1071                &local_var_str
1072                    .into_iter()
1073                    .map(|p| ("id__n".to_owned(), p.to_string()))
1074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1075            ),
1076            _ => local_var_req_builder.query(&[(
1077                "id__n",
1078                &local_var_str
1079                    .into_iter()
1080                    .map(|p| p.to_string())
1081                    .collect::<Vec<String>>()
1082                    .join(",")
1083                    .to_string(),
1084            )]),
1085        };
1086    }
1087    if let Some(ref local_var_str) = last_updated {
1088        local_var_req_builder = match "multi" {
1089            "multi" => local_var_req_builder.query(
1090                &local_var_str
1091                    .into_iter()
1092                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1094            ),
1095            _ => local_var_req_builder.query(&[(
1096                "last_updated",
1097                &local_var_str
1098                    .into_iter()
1099                    .map(|p| p.to_string())
1100                    .collect::<Vec<String>>()
1101                    .join(",")
1102                    .to_string(),
1103            )]),
1104        };
1105    }
1106    if let Some(ref local_var_str) = last_updated__empty {
1107        local_var_req_builder = match "multi" {
1108            "multi" => local_var_req_builder.query(
1109                &local_var_str
1110                    .into_iter()
1111                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1113            ),
1114            _ => local_var_req_builder.query(&[(
1115                "last_updated__empty",
1116                &local_var_str
1117                    .into_iter()
1118                    .map(|p| p.to_string())
1119                    .collect::<Vec<String>>()
1120                    .join(",")
1121                    .to_string(),
1122            )]),
1123        };
1124    }
1125    if let Some(ref local_var_str) = last_updated__gt {
1126        local_var_req_builder = match "multi" {
1127            "multi" => local_var_req_builder.query(
1128                &local_var_str
1129                    .into_iter()
1130                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1132            ),
1133            _ => local_var_req_builder.query(&[(
1134                "last_updated__gt",
1135                &local_var_str
1136                    .into_iter()
1137                    .map(|p| p.to_string())
1138                    .collect::<Vec<String>>()
1139                    .join(",")
1140                    .to_string(),
1141            )]),
1142        };
1143    }
1144    if let Some(ref local_var_str) = last_updated__gte {
1145        local_var_req_builder = match "multi" {
1146            "multi" => local_var_req_builder.query(
1147                &local_var_str
1148                    .into_iter()
1149                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1151            ),
1152            _ => local_var_req_builder.query(&[(
1153                "last_updated__gte",
1154                &local_var_str
1155                    .into_iter()
1156                    .map(|p| p.to_string())
1157                    .collect::<Vec<String>>()
1158                    .join(",")
1159                    .to_string(),
1160            )]),
1161        };
1162    }
1163    if let Some(ref local_var_str) = last_updated__lt {
1164        local_var_req_builder = match "multi" {
1165            "multi" => local_var_req_builder.query(
1166                &local_var_str
1167                    .into_iter()
1168                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1170            ),
1171            _ => local_var_req_builder.query(&[(
1172                "last_updated__lt",
1173                &local_var_str
1174                    .into_iter()
1175                    .map(|p| p.to_string())
1176                    .collect::<Vec<String>>()
1177                    .join(",")
1178                    .to_string(),
1179            )]),
1180        };
1181    }
1182    if let Some(ref local_var_str) = last_updated__lte {
1183        local_var_req_builder = match "multi" {
1184            "multi" => local_var_req_builder.query(
1185                &local_var_str
1186                    .into_iter()
1187                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1189            ),
1190            _ => local_var_req_builder.query(&[(
1191                "last_updated__lte",
1192                &local_var_str
1193                    .into_iter()
1194                    .map(|p| p.to_string())
1195                    .collect::<Vec<String>>()
1196                    .join(",")
1197                    .to_string(),
1198            )]),
1199        };
1200    }
1201    if let Some(ref local_var_str) = last_updated__n {
1202        local_var_req_builder = match "multi" {
1203            "multi" => local_var_req_builder.query(
1204                &local_var_str
1205                    .into_iter()
1206                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1208            ),
1209            _ => local_var_req_builder.query(&[(
1210                "last_updated__n",
1211                &local_var_str
1212                    .into_iter()
1213                    .map(|p| p.to_string())
1214                    .collect::<Vec<String>>()
1215                    .join(",")
1216                    .to_string(),
1217            )]),
1218        };
1219    }
1220    if let Some(ref local_var_str) = limit {
1221        local_var_req_builder =
1222            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1223    }
1224    if let Some(ref local_var_str) = modified_by_request {
1225        local_var_req_builder =
1226            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1227    }
1228    if let Some(ref local_var_str) = object_id {
1229        local_var_req_builder = match "multi" {
1230            "multi" => local_var_req_builder.query(
1231                &local_var_str
1232                    .into_iter()
1233                    .map(|p| ("object_id".to_owned(), p.to_string()))
1234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1235            ),
1236            _ => local_var_req_builder.query(&[(
1237                "object_id",
1238                &local_var_str
1239                    .into_iter()
1240                    .map(|p| p.to_string())
1241                    .collect::<Vec<String>>()
1242                    .join(",")
1243                    .to_string(),
1244            )]),
1245        };
1246    }
1247    if let Some(ref local_var_str) = object_id__empty {
1248        local_var_req_builder =
1249            local_var_req_builder.query(&[("object_id__empty", &local_var_str.to_string())]);
1250    }
1251    if let Some(ref local_var_str) = object_id__gt {
1252        local_var_req_builder = match "multi" {
1253            "multi" => local_var_req_builder.query(
1254                &local_var_str
1255                    .into_iter()
1256                    .map(|p| ("object_id__gt".to_owned(), p.to_string()))
1257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1258            ),
1259            _ => local_var_req_builder.query(&[(
1260                "object_id__gt",
1261                &local_var_str
1262                    .into_iter()
1263                    .map(|p| p.to_string())
1264                    .collect::<Vec<String>>()
1265                    .join(",")
1266                    .to_string(),
1267            )]),
1268        };
1269    }
1270    if let Some(ref local_var_str) = object_id__gte {
1271        local_var_req_builder = match "multi" {
1272            "multi" => local_var_req_builder.query(
1273                &local_var_str
1274                    .into_iter()
1275                    .map(|p| ("object_id__gte".to_owned(), p.to_string()))
1276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1277            ),
1278            _ => local_var_req_builder.query(&[(
1279                "object_id__gte",
1280                &local_var_str
1281                    .into_iter()
1282                    .map(|p| p.to_string())
1283                    .collect::<Vec<String>>()
1284                    .join(",")
1285                    .to_string(),
1286            )]),
1287        };
1288    }
1289    if let Some(ref local_var_str) = object_id__lt {
1290        local_var_req_builder = match "multi" {
1291            "multi" => local_var_req_builder.query(
1292                &local_var_str
1293                    .into_iter()
1294                    .map(|p| ("object_id__lt".to_owned(), p.to_string()))
1295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1296            ),
1297            _ => local_var_req_builder.query(&[(
1298                "object_id__lt",
1299                &local_var_str
1300                    .into_iter()
1301                    .map(|p| p.to_string())
1302                    .collect::<Vec<String>>()
1303                    .join(",")
1304                    .to_string(),
1305            )]),
1306        };
1307    }
1308    if let Some(ref local_var_str) = object_id__lte {
1309        local_var_req_builder = match "multi" {
1310            "multi" => local_var_req_builder.query(
1311                &local_var_str
1312                    .into_iter()
1313                    .map(|p| ("object_id__lte".to_owned(), p.to_string()))
1314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1315            ),
1316            _ => local_var_req_builder.query(&[(
1317                "object_id__lte",
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| p.to_string())
1321                    .collect::<Vec<String>>()
1322                    .join(",")
1323                    .to_string(),
1324            )]),
1325        };
1326    }
1327    if let Some(ref local_var_str) = object_id__n {
1328        local_var_req_builder = match "multi" {
1329            "multi" => local_var_req_builder.query(
1330                &local_var_str
1331                    .into_iter()
1332                    .map(|p| ("object_id__n".to_owned(), p.to_string()))
1333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1334            ),
1335            _ => local_var_req_builder.query(&[(
1336                "object_id__n",
1337                &local_var_str
1338                    .into_iter()
1339                    .map(|p| p.to_string())
1340                    .collect::<Vec<String>>()
1341                    .join(",")
1342                    .to_string(),
1343            )]),
1344        };
1345    }
1346    if let Some(ref local_var_str) = object_type {
1347        local_var_req_builder =
1348            local_var_req_builder.query(&[("object_type", &local_var_str.to_string())]);
1349    }
1350    if let Some(ref local_var_str) = object_type__n {
1351        local_var_req_builder =
1352            local_var_req_builder.query(&[("object_type__n", &local_var_str.to_string())]);
1353    }
1354    if let Some(ref local_var_str) = object_type_id {
1355        local_var_req_builder =
1356            local_var_req_builder.query(&[("object_type_id", &local_var_str.to_string())]);
1357    }
1358    if let Some(ref local_var_str) = object_type_id__n {
1359        local_var_req_builder =
1360            local_var_req_builder.query(&[("object_type_id__n", &local_var_str.to_string())]);
1361    }
1362    if let Some(ref local_var_str) = offset {
1363        local_var_req_builder =
1364            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1365    }
1366    if let Some(ref local_var_str) = ordering {
1367        local_var_req_builder =
1368            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1369    }
1370    if let Some(ref local_var_str) = priority {
1371        local_var_req_builder =
1372            local_var_req_builder.query(&[("priority", &local_var_str.to_string())]);
1373    }
1374    if let Some(ref local_var_str) = q {
1375        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1376    }
1377    if let Some(ref local_var_str) = role {
1378        local_var_req_builder = match "multi" {
1379            "multi" => local_var_req_builder.query(
1380                &local_var_str
1381                    .into_iter()
1382                    .map(|p| ("role".to_owned(), p.to_string()))
1383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1384            ),
1385            _ => local_var_req_builder.query(&[(
1386                "role",
1387                &local_var_str
1388                    .into_iter()
1389                    .map(|p| p.to_string())
1390                    .collect::<Vec<String>>()
1391                    .join(",")
1392                    .to_string(),
1393            )]),
1394        };
1395    }
1396    if let Some(ref local_var_str) = role__n {
1397        local_var_req_builder = match "multi" {
1398            "multi" => local_var_req_builder.query(
1399                &local_var_str
1400                    .into_iter()
1401                    .map(|p| ("role__n".to_owned(), p.to_string()))
1402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1403            ),
1404            _ => local_var_req_builder.query(&[(
1405                "role__n",
1406                &local_var_str
1407                    .into_iter()
1408                    .map(|p| p.to_string())
1409                    .collect::<Vec<String>>()
1410                    .join(",")
1411                    .to_string(),
1412            )]),
1413        };
1414    }
1415    if let Some(ref local_var_str) = role_id {
1416        local_var_req_builder = match "multi" {
1417            "multi" => local_var_req_builder.query(
1418                &local_var_str
1419                    .into_iter()
1420                    .map(|p| ("role_id".to_owned(), p.to_string()))
1421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1422            ),
1423            _ => local_var_req_builder.query(&[(
1424                "role_id",
1425                &local_var_str
1426                    .into_iter()
1427                    .map(|p| p.to_string())
1428                    .collect::<Vec<String>>()
1429                    .join(",")
1430                    .to_string(),
1431            )]),
1432        };
1433    }
1434    if let Some(ref local_var_str) = role_id__n {
1435        local_var_req_builder = match "multi" {
1436            "multi" => local_var_req_builder.query(
1437                &local_var_str
1438                    .into_iter()
1439                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
1440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1441            ),
1442            _ => local_var_req_builder.query(&[(
1443                "role_id__n",
1444                &local_var_str
1445                    .into_iter()
1446                    .map(|p| p.to_string())
1447                    .collect::<Vec<String>>()
1448                    .join(",")
1449                    .to_string(),
1450            )]),
1451        };
1452    }
1453    if let Some(ref local_var_str) = tag {
1454        local_var_req_builder = match "multi" {
1455            "multi" => local_var_req_builder.query(
1456                &local_var_str
1457                    .into_iter()
1458                    .map(|p| ("tag".to_owned(), p.to_string()))
1459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1460            ),
1461            _ => local_var_req_builder.query(&[(
1462                "tag",
1463                &local_var_str
1464                    .into_iter()
1465                    .map(|p| p.to_string())
1466                    .collect::<Vec<String>>()
1467                    .join(",")
1468                    .to_string(),
1469            )]),
1470        };
1471    }
1472    if let Some(ref local_var_str) = tag__n {
1473        local_var_req_builder = match "multi" {
1474            "multi" => local_var_req_builder.query(
1475                &local_var_str
1476                    .into_iter()
1477                    .map(|p| ("tag__n".to_owned(), p.to_string()))
1478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1479            ),
1480            _ => local_var_req_builder.query(&[(
1481                "tag__n",
1482                &local_var_str
1483                    .into_iter()
1484                    .map(|p| p.to_string())
1485                    .collect::<Vec<String>>()
1486                    .join(",")
1487                    .to_string(),
1488            )]),
1489        };
1490    }
1491    if let Some(ref local_var_str) = tag_id {
1492        local_var_req_builder = match "multi" {
1493            "multi" => local_var_req_builder.query(
1494                &local_var_str
1495                    .into_iter()
1496                    .map(|p| ("tag_id".to_owned(), p.to_string()))
1497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1498            ),
1499            _ => local_var_req_builder.query(&[(
1500                "tag_id",
1501                &local_var_str
1502                    .into_iter()
1503                    .map(|p| p.to_string())
1504                    .collect::<Vec<String>>()
1505                    .join(",")
1506                    .to_string(),
1507            )]),
1508        };
1509    }
1510    if let Some(ref local_var_str) = tag_id__n {
1511        local_var_req_builder = match "multi" {
1512            "multi" => local_var_req_builder.query(
1513                &local_var_str
1514                    .into_iter()
1515                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
1516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1517            ),
1518            _ => local_var_req_builder.query(&[(
1519                "tag_id__n",
1520                &local_var_str
1521                    .into_iter()
1522                    .map(|p| p.to_string())
1523                    .collect::<Vec<String>>()
1524                    .join(",")
1525                    .to_string(),
1526            )]),
1527        };
1528    }
1529    if let Some(ref local_var_str) = updated_by_request {
1530        local_var_req_builder =
1531            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
1532    }
1533    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1534        local_var_req_builder =
1535            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1536    }
1537    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1538        let local_var_key = local_var_apikey.key.clone();
1539        let local_var_value = match local_var_apikey.prefix {
1540            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1541            None => local_var_key,
1542        };
1543        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1544    };
1545
1546    let local_var_req = local_var_req_builder.build()?;
1547    let local_var_resp = local_var_client.execute(local_var_req).await?;
1548
1549    let local_var_status = local_var_resp.status();
1550    let local_var_content = local_var_resp.text().await?;
1551
1552    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1553        serde_json::from_str(&local_var_content).map_err(Error::from)
1554    } else {
1555        let local_var_entity: Option<TenancyContactAssignmentsListError> =
1556            serde_json::from_str(&local_var_content).ok();
1557        let local_var_error = ResponseContent {
1558            status: local_var_status,
1559            content: local_var_content,
1560            entity: local_var_entity,
1561        };
1562        Err(Error::ResponseError(local_var_error))
1563    }
1564}
1565
1566/// Patch a contact assignment object.
1567pub async fn tenancy_contact_assignments_partial_update(
1568    configuration: &configuration::Configuration,
1569    id: i32,
1570    patched_writable_contact_assignment_request: Option<
1571        crate::models::PatchedWritableContactAssignmentRequest,
1572    >,
1573) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsPartialUpdateError>> {
1574    let local_var_configuration = configuration;
1575
1576    let local_var_client = &local_var_configuration.client;
1577
1578    let local_var_uri_str = format!(
1579        "{}/api/tenancy/contact-assignments/{id}/",
1580        local_var_configuration.base_path,
1581        id = id
1582    );
1583    let mut local_var_req_builder =
1584        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1585
1586    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1587        local_var_req_builder =
1588            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1589    }
1590    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1591        let local_var_key = local_var_apikey.key.clone();
1592        let local_var_value = match local_var_apikey.prefix {
1593            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1594            None => local_var_key,
1595        };
1596        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1597    };
1598    local_var_req_builder =
1599        local_var_req_builder.json(&patched_writable_contact_assignment_request);
1600
1601    let local_var_req = local_var_req_builder.build()?;
1602    let local_var_resp = local_var_client.execute(local_var_req).await?;
1603
1604    let local_var_status = local_var_resp.status();
1605    let local_var_content = local_var_resp.text().await?;
1606
1607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1608        serde_json::from_str(&local_var_content).map_err(Error::from)
1609    } else {
1610        let local_var_entity: Option<TenancyContactAssignmentsPartialUpdateError> =
1611            serde_json::from_str(&local_var_content).ok();
1612        let local_var_error = ResponseContent {
1613            status: local_var_status,
1614            content: local_var_content,
1615            entity: local_var_entity,
1616        };
1617        Err(Error::ResponseError(local_var_error))
1618    }
1619}
1620
1621/// Get a contact assignment object.
1622pub async fn tenancy_contact_assignments_retrieve(
1623    configuration: &configuration::Configuration,
1624    id: i32,
1625) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsRetrieveError>> {
1626    let local_var_configuration = configuration;
1627
1628    let local_var_client = &local_var_configuration.client;
1629
1630    let local_var_uri_str = format!(
1631        "{}/api/tenancy/contact-assignments/{id}/",
1632        local_var_configuration.base_path,
1633        id = id
1634    );
1635    let mut local_var_req_builder =
1636        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1637
1638    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1639        local_var_req_builder =
1640            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1641    }
1642    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1643        let local_var_key = local_var_apikey.key.clone();
1644        let local_var_value = match local_var_apikey.prefix {
1645            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1646            None => local_var_key,
1647        };
1648        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1649    };
1650
1651    let local_var_req = local_var_req_builder.build()?;
1652    let local_var_resp = local_var_client.execute(local_var_req).await?;
1653
1654    let local_var_status = local_var_resp.status();
1655    let local_var_content = local_var_resp.text().await?;
1656
1657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1658        serde_json::from_str(&local_var_content).map_err(Error::from)
1659    } else {
1660        let local_var_entity: Option<TenancyContactAssignmentsRetrieveError> =
1661            serde_json::from_str(&local_var_content).ok();
1662        let local_var_error = ResponseContent {
1663            status: local_var_status,
1664            content: local_var_content,
1665            entity: local_var_entity,
1666        };
1667        Err(Error::ResponseError(local_var_error))
1668    }
1669}
1670
1671/// Put a contact assignment object.
1672pub async fn tenancy_contact_assignments_update(
1673    configuration: &configuration::Configuration,
1674    id: i32,
1675    writable_contact_assignment_request: crate::models::WritableContactAssignmentRequest,
1676) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsUpdateError>> {
1677    let local_var_configuration = configuration;
1678
1679    let local_var_client = &local_var_configuration.client;
1680
1681    let local_var_uri_str = format!(
1682        "{}/api/tenancy/contact-assignments/{id}/",
1683        local_var_configuration.base_path,
1684        id = id
1685    );
1686    let mut local_var_req_builder =
1687        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1688
1689    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1690        local_var_req_builder =
1691            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1692    }
1693    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1694        let local_var_key = local_var_apikey.key.clone();
1695        let local_var_value = match local_var_apikey.prefix {
1696            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1697            None => local_var_key,
1698        };
1699        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1700    };
1701    local_var_req_builder = local_var_req_builder.json(&writable_contact_assignment_request);
1702
1703    let local_var_req = local_var_req_builder.build()?;
1704    let local_var_resp = local_var_client.execute(local_var_req).await?;
1705
1706    let local_var_status = local_var_resp.status();
1707    let local_var_content = local_var_resp.text().await?;
1708
1709    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1710        serde_json::from_str(&local_var_content).map_err(Error::from)
1711    } else {
1712        let local_var_entity: Option<TenancyContactAssignmentsUpdateError> =
1713            serde_json::from_str(&local_var_content).ok();
1714        let local_var_error = ResponseContent {
1715            status: local_var_status,
1716            content: local_var_content,
1717            entity: local_var_entity,
1718        };
1719        Err(Error::ResponseError(local_var_error))
1720    }
1721}
1722
1723/// Delete a list of contact group objects.
1724pub async fn tenancy_contact_groups_bulk_destroy(
1725    configuration: &configuration::Configuration,
1726    contact_group_request: Vec<crate::models::ContactGroupRequest>,
1727) -> Result<(), Error<TenancyContactGroupsBulkDestroyError>> {
1728    let local_var_configuration = configuration;
1729
1730    let local_var_client = &local_var_configuration.client;
1731
1732    let local_var_uri_str = format!(
1733        "{}/api/tenancy/contact-groups/",
1734        local_var_configuration.base_path
1735    );
1736    let mut local_var_req_builder =
1737        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1738
1739    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1740        local_var_req_builder =
1741            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1742    }
1743    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1744        let local_var_key = local_var_apikey.key.clone();
1745        let local_var_value = match local_var_apikey.prefix {
1746            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1747            None => local_var_key,
1748        };
1749        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1750    };
1751    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
1752
1753    let local_var_req = local_var_req_builder.build()?;
1754    let local_var_resp = local_var_client.execute(local_var_req).await?;
1755
1756    let local_var_status = local_var_resp.status();
1757    let local_var_content = local_var_resp.text().await?;
1758
1759    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1760        Ok(())
1761    } else {
1762        let local_var_entity: Option<TenancyContactGroupsBulkDestroyError> =
1763            serde_json::from_str(&local_var_content).ok();
1764        let local_var_error = ResponseContent {
1765            status: local_var_status,
1766            content: local_var_content,
1767            entity: local_var_entity,
1768        };
1769        Err(Error::ResponseError(local_var_error))
1770    }
1771}
1772
1773/// Patch a list of contact group objects.
1774pub async fn tenancy_contact_groups_bulk_partial_update(
1775    configuration: &configuration::Configuration,
1776    contact_group_request: Vec<crate::models::ContactGroupRequest>,
1777) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkPartialUpdateError>> {
1778    let local_var_configuration = configuration;
1779
1780    let local_var_client = &local_var_configuration.client;
1781
1782    let local_var_uri_str = format!(
1783        "{}/api/tenancy/contact-groups/",
1784        local_var_configuration.base_path
1785    );
1786    let mut local_var_req_builder =
1787        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1788
1789    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1790        local_var_req_builder =
1791            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1792    }
1793    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1794        let local_var_key = local_var_apikey.key.clone();
1795        let local_var_value = match local_var_apikey.prefix {
1796            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1797            None => local_var_key,
1798        };
1799        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1800    };
1801    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
1802
1803    let local_var_req = local_var_req_builder.build()?;
1804    let local_var_resp = local_var_client.execute(local_var_req).await?;
1805
1806    let local_var_status = local_var_resp.status();
1807    let local_var_content = local_var_resp.text().await?;
1808
1809    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1810        serde_json::from_str(&local_var_content).map_err(Error::from)
1811    } else {
1812        let local_var_entity: Option<TenancyContactGroupsBulkPartialUpdateError> =
1813            serde_json::from_str(&local_var_content).ok();
1814        let local_var_error = ResponseContent {
1815            status: local_var_status,
1816            content: local_var_content,
1817            entity: local_var_entity,
1818        };
1819        Err(Error::ResponseError(local_var_error))
1820    }
1821}
1822
1823/// Put a list of contact group objects.
1824pub async fn tenancy_contact_groups_bulk_update(
1825    configuration: &configuration::Configuration,
1826    contact_group_request: Vec<crate::models::ContactGroupRequest>,
1827) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkUpdateError>> {
1828    let local_var_configuration = configuration;
1829
1830    let local_var_client = &local_var_configuration.client;
1831
1832    let local_var_uri_str = format!(
1833        "{}/api/tenancy/contact-groups/",
1834        local_var_configuration.base_path
1835    );
1836    let mut local_var_req_builder =
1837        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1838
1839    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1840        local_var_req_builder =
1841            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1842    }
1843    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1844        let local_var_key = local_var_apikey.key.clone();
1845        let local_var_value = match local_var_apikey.prefix {
1846            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1847            None => local_var_key,
1848        };
1849        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1850    };
1851    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
1852
1853    let local_var_req = local_var_req_builder.build()?;
1854    let local_var_resp = local_var_client.execute(local_var_req).await?;
1855
1856    let local_var_status = local_var_resp.status();
1857    let local_var_content = local_var_resp.text().await?;
1858
1859    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1860        serde_json::from_str(&local_var_content).map_err(Error::from)
1861    } else {
1862        let local_var_entity: Option<TenancyContactGroupsBulkUpdateError> =
1863            serde_json::from_str(&local_var_content).ok();
1864        let local_var_error = ResponseContent {
1865            status: local_var_status,
1866            content: local_var_content,
1867            entity: local_var_entity,
1868        };
1869        Err(Error::ResponseError(local_var_error))
1870    }
1871}
1872
1873/// Post a list of contact group objects.
1874pub async fn tenancy_contact_groups_create(
1875    configuration: &configuration::Configuration,
1876    writable_contact_group_request: crate::models::WritableContactGroupRequest,
1877) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsCreateError>> {
1878    let local_var_configuration = configuration;
1879
1880    let local_var_client = &local_var_configuration.client;
1881
1882    let local_var_uri_str = format!(
1883        "{}/api/tenancy/contact-groups/",
1884        local_var_configuration.base_path
1885    );
1886    let mut local_var_req_builder =
1887        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1888
1889    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1890        local_var_req_builder =
1891            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1892    }
1893    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1894        let local_var_key = local_var_apikey.key.clone();
1895        let local_var_value = match local_var_apikey.prefix {
1896            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1897            None => local_var_key,
1898        };
1899        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1900    };
1901    local_var_req_builder = local_var_req_builder.json(&writable_contact_group_request);
1902
1903    let local_var_req = local_var_req_builder.build()?;
1904    let local_var_resp = local_var_client.execute(local_var_req).await?;
1905
1906    let local_var_status = local_var_resp.status();
1907    let local_var_content = local_var_resp.text().await?;
1908
1909    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1910        serde_json::from_str(&local_var_content).map_err(Error::from)
1911    } else {
1912        let local_var_entity: Option<TenancyContactGroupsCreateError> =
1913            serde_json::from_str(&local_var_content).ok();
1914        let local_var_error = ResponseContent {
1915            status: local_var_status,
1916            content: local_var_content,
1917            entity: local_var_entity,
1918        };
1919        Err(Error::ResponseError(local_var_error))
1920    }
1921}
1922
1923/// Delete a contact group object.
1924pub async fn tenancy_contact_groups_destroy(
1925    configuration: &configuration::Configuration,
1926    id: i32,
1927) -> Result<(), Error<TenancyContactGroupsDestroyError>> {
1928    let local_var_configuration = configuration;
1929
1930    let local_var_client = &local_var_configuration.client;
1931
1932    let local_var_uri_str = format!(
1933        "{}/api/tenancy/contact-groups/{id}/",
1934        local_var_configuration.base_path,
1935        id = id
1936    );
1937    let mut local_var_req_builder =
1938        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1939
1940    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1941        local_var_req_builder =
1942            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1943    }
1944    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1945        let local_var_key = local_var_apikey.key.clone();
1946        let local_var_value = match local_var_apikey.prefix {
1947            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1948            None => local_var_key,
1949        };
1950        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1951    };
1952
1953    let local_var_req = local_var_req_builder.build()?;
1954    let local_var_resp = local_var_client.execute(local_var_req).await?;
1955
1956    let local_var_status = local_var_resp.status();
1957    let local_var_content = local_var_resp.text().await?;
1958
1959    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1960        Ok(())
1961    } else {
1962        let local_var_entity: Option<TenancyContactGroupsDestroyError> =
1963            serde_json::from_str(&local_var_content).ok();
1964        let local_var_error = ResponseContent {
1965            status: local_var_status,
1966            content: local_var_content,
1967            entity: local_var_entity,
1968        };
1969        Err(Error::ResponseError(local_var_error))
1970    }
1971}
1972
1973/// Get a list of contact group objects.
1974pub async fn tenancy_contact_groups_list(
1975    configuration: &configuration::Configuration,
1976    ancestor: Option<Vec<String>>,
1977    ancestor__n: Option<Vec<String>>,
1978    ancestor_id: Option<Vec<String>>,
1979    ancestor_id__n: Option<Vec<String>>,
1980    contact_id: Option<Vec<i32>>,
1981    contact_id__n: Option<Vec<i32>>,
1982    created: Option<Vec<String>>,
1983    created__empty: Option<Vec<String>>,
1984    created__gt: Option<Vec<String>>,
1985    created__gte: Option<Vec<String>>,
1986    created__lt: Option<Vec<String>>,
1987    created__lte: Option<Vec<String>>,
1988    created__n: Option<Vec<String>>,
1989    created_by_request: Option<&str>,
1990    description: Option<Vec<String>>,
1991    description__empty: Option<bool>,
1992    description__ic: Option<Vec<String>>,
1993    description__ie: Option<Vec<String>>,
1994    description__iew: Option<Vec<String>>,
1995    description__iregex: Option<Vec<String>>,
1996    description__isw: Option<Vec<String>>,
1997    description__n: Option<Vec<String>>,
1998    description__nic: Option<Vec<String>>,
1999    description__nie: Option<Vec<String>>,
2000    description__niew: Option<Vec<String>>,
2001    description__nisw: Option<Vec<String>>,
2002    description__regex: Option<Vec<String>>,
2003    id: Option<Vec<i32>>,
2004    id__empty: Option<bool>,
2005    id__gt: Option<Vec<i32>>,
2006    id__gte: Option<Vec<i32>>,
2007    id__lt: Option<Vec<i32>>,
2008    id__lte: Option<Vec<i32>>,
2009    id__n: Option<Vec<i32>>,
2010    last_updated: Option<Vec<String>>,
2011    last_updated__empty: Option<Vec<String>>,
2012    last_updated__gt: Option<Vec<String>>,
2013    last_updated__gte: Option<Vec<String>>,
2014    last_updated__lt: Option<Vec<String>>,
2015    last_updated__lte: Option<Vec<String>>,
2016    last_updated__n: Option<Vec<String>>,
2017    limit: Option<i32>,
2018    modified_by_request: Option<&str>,
2019    name: Option<Vec<String>>,
2020    name__empty: Option<bool>,
2021    name__ic: Option<Vec<String>>,
2022    name__ie: Option<Vec<String>>,
2023    name__iew: Option<Vec<String>>,
2024    name__iregex: Option<Vec<String>>,
2025    name__isw: Option<Vec<String>>,
2026    name__n: Option<Vec<String>>,
2027    name__nic: Option<Vec<String>>,
2028    name__nie: Option<Vec<String>>,
2029    name__niew: Option<Vec<String>>,
2030    name__nisw: Option<Vec<String>>,
2031    name__regex: Option<Vec<String>>,
2032    offset: Option<i32>,
2033    ordering: Option<&str>,
2034    parent: Option<Vec<String>>,
2035    parent__n: Option<Vec<String>>,
2036    parent_id: Option<Vec<i32>>,
2037    parent_id__n: Option<Vec<i32>>,
2038    q: Option<&str>,
2039    slug: Option<Vec<String>>,
2040    slug__empty: Option<bool>,
2041    slug__ic: Option<Vec<String>>,
2042    slug__ie: Option<Vec<String>>,
2043    slug__iew: Option<Vec<String>>,
2044    slug__iregex: Option<Vec<String>>,
2045    slug__isw: Option<Vec<String>>,
2046    slug__n: Option<Vec<String>>,
2047    slug__nic: Option<Vec<String>>,
2048    slug__nie: Option<Vec<String>>,
2049    slug__niew: Option<Vec<String>>,
2050    slug__nisw: Option<Vec<String>>,
2051    slug__regex: Option<Vec<String>>,
2052    tag: Option<Vec<String>>,
2053    tag__n: Option<Vec<String>>,
2054    tag_id: Option<Vec<i32>>,
2055    tag_id__n: Option<Vec<i32>>,
2056    updated_by_request: Option<&str>,
2057) -> Result<crate::models::PaginatedContactGroupList, Error<TenancyContactGroupsListError>> {
2058    let local_var_configuration = configuration;
2059
2060    let local_var_client = &local_var_configuration.client;
2061
2062    let local_var_uri_str = format!(
2063        "{}/api/tenancy/contact-groups/",
2064        local_var_configuration.base_path
2065    );
2066    let mut local_var_req_builder =
2067        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2068
2069    if let Some(ref local_var_str) = ancestor {
2070        local_var_req_builder = match "multi" {
2071            "multi" => local_var_req_builder.query(
2072                &local_var_str
2073                    .into_iter()
2074                    .map(|p| ("ancestor".to_owned(), p.to_string()))
2075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2076            ),
2077            _ => local_var_req_builder.query(&[(
2078                "ancestor",
2079                &local_var_str
2080                    .into_iter()
2081                    .map(|p| p.to_string())
2082                    .collect::<Vec<String>>()
2083                    .join(",")
2084                    .to_string(),
2085            )]),
2086        };
2087    }
2088    if let Some(ref local_var_str) = ancestor__n {
2089        local_var_req_builder = match "multi" {
2090            "multi" => local_var_req_builder.query(
2091                &local_var_str
2092                    .into_iter()
2093                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
2094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2095            ),
2096            _ => local_var_req_builder.query(&[(
2097                "ancestor__n",
2098                &local_var_str
2099                    .into_iter()
2100                    .map(|p| p.to_string())
2101                    .collect::<Vec<String>>()
2102                    .join(",")
2103                    .to_string(),
2104            )]),
2105        };
2106    }
2107    if let Some(ref local_var_str) = ancestor_id {
2108        local_var_req_builder = match "multi" {
2109            "multi" => local_var_req_builder.query(
2110                &local_var_str
2111                    .into_iter()
2112                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
2113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2114            ),
2115            _ => local_var_req_builder.query(&[(
2116                "ancestor_id",
2117                &local_var_str
2118                    .into_iter()
2119                    .map(|p| p.to_string())
2120                    .collect::<Vec<String>>()
2121                    .join(",")
2122                    .to_string(),
2123            )]),
2124        };
2125    }
2126    if let Some(ref local_var_str) = ancestor_id__n {
2127        local_var_req_builder = match "multi" {
2128            "multi" => local_var_req_builder.query(
2129                &local_var_str
2130                    .into_iter()
2131                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
2132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2133            ),
2134            _ => local_var_req_builder.query(&[(
2135                "ancestor_id__n",
2136                &local_var_str
2137                    .into_iter()
2138                    .map(|p| p.to_string())
2139                    .collect::<Vec<String>>()
2140                    .join(",")
2141                    .to_string(),
2142            )]),
2143        };
2144    }
2145    if let Some(ref local_var_str) = contact_id {
2146        local_var_req_builder = match "multi" {
2147            "multi" => local_var_req_builder.query(
2148                &local_var_str
2149                    .into_iter()
2150                    .map(|p| ("contact_id".to_owned(), p.to_string()))
2151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2152            ),
2153            _ => local_var_req_builder.query(&[(
2154                "contact_id",
2155                &local_var_str
2156                    .into_iter()
2157                    .map(|p| p.to_string())
2158                    .collect::<Vec<String>>()
2159                    .join(",")
2160                    .to_string(),
2161            )]),
2162        };
2163    }
2164    if let Some(ref local_var_str) = contact_id__n {
2165        local_var_req_builder = match "multi" {
2166            "multi" => local_var_req_builder.query(
2167                &local_var_str
2168                    .into_iter()
2169                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
2170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2171            ),
2172            _ => local_var_req_builder.query(&[(
2173                "contact_id__n",
2174                &local_var_str
2175                    .into_iter()
2176                    .map(|p| p.to_string())
2177                    .collect::<Vec<String>>()
2178                    .join(",")
2179                    .to_string(),
2180            )]),
2181        };
2182    }
2183    if let Some(ref local_var_str) = created {
2184        local_var_req_builder = match "multi" {
2185            "multi" => local_var_req_builder.query(
2186                &local_var_str
2187                    .into_iter()
2188                    .map(|p| ("created".to_owned(), p.to_string()))
2189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2190            ),
2191            _ => local_var_req_builder.query(&[(
2192                "created",
2193                &local_var_str
2194                    .into_iter()
2195                    .map(|p| p.to_string())
2196                    .collect::<Vec<String>>()
2197                    .join(",")
2198                    .to_string(),
2199            )]),
2200        };
2201    }
2202    if let Some(ref local_var_str) = created__empty {
2203        local_var_req_builder = match "multi" {
2204            "multi" => local_var_req_builder.query(
2205                &local_var_str
2206                    .into_iter()
2207                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2209            ),
2210            _ => local_var_req_builder.query(&[(
2211                "created__empty",
2212                &local_var_str
2213                    .into_iter()
2214                    .map(|p| p.to_string())
2215                    .collect::<Vec<String>>()
2216                    .join(",")
2217                    .to_string(),
2218            )]),
2219        };
2220    }
2221    if let Some(ref local_var_str) = created__gt {
2222        local_var_req_builder = match "multi" {
2223            "multi" => local_var_req_builder.query(
2224                &local_var_str
2225                    .into_iter()
2226                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2228            ),
2229            _ => local_var_req_builder.query(&[(
2230                "created__gt",
2231                &local_var_str
2232                    .into_iter()
2233                    .map(|p| p.to_string())
2234                    .collect::<Vec<String>>()
2235                    .join(",")
2236                    .to_string(),
2237            )]),
2238        };
2239    }
2240    if let Some(ref local_var_str) = created__gte {
2241        local_var_req_builder = match "multi" {
2242            "multi" => local_var_req_builder.query(
2243                &local_var_str
2244                    .into_iter()
2245                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2247            ),
2248            _ => local_var_req_builder.query(&[(
2249                "created__gte",
2250                &local_var_str
2251                    .into_iter()
2252                    .map(|p| p.to_string())
2253                    .collect::<Vec<String>>()
2254                    .join(",")
2255                    .to_string(),
2256            )]),
2257        };
2258    }
2259    if let Some(ref local_var_str) = created__lt {
2260        local_var_req_builder = match "multi" {
2261            "multi" => local_var_req_builder.query(
2262                &local_var_str
2263                    .into_iter()
2264                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2266            ),
2267            _ => local_var_req_builder.query(&[(
2268                "created__lt",
2269                &local_var_str
2270                    .into_iter()
2271                    .map(|p| p.to_string())
2272                    .collect::<Vec<String>>()
2273                    .join(",")
2274                    .to_string(),
2275            )]),
2276        };
2277    }
2278    if let Some(ref local_var_str) = created__lte {
2279        local_var_req_builder = match "multi" {
2280            "multi" => local_var_req_builder.query(
2281                &local_var_str
2282                    .into_iter()
2283                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2285            ),
2286            _ => local_var_req_builder.query(&[(
2287                "created__lte",
2288                &local_var_str
2289                    .into_iter()
2290                    .map(|p| p.to_string())
2291                    .collect::<Vec<String>>()
2292                    .join(",")
2293                    .to_string(),
2294            )]),
2295        };
2296    }
2297    if let Some(ref local_var_str) = created__n {
2298        local_var_req_builder = match "multi" {
2299            "multi" => local_var_req_builder.query(
2300                &local_var_str
2301                    .into_iter()
2302                    .map(|p| ("created__n".to_owned(), p.to_string()))
2303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2304            ),
2305            _ => local_var_req_builder.query(&[(
2306                "created__n",
2307                &local_var_str
2308                    .into_iter()
2309                    .map(|p| p.to_string())
2310                    .collect::<Vec<String>>()
2311                    .join(",")
2312                    .to_string(),
2313            )]),
2314        };
2315    }
2316    if let Some(ref local_var_str) = created_by_request {
2317        local_var_req_builder =
2318            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2319    }
2320    if let Some(ref local_var_str) = description {
2321        local_var_req_builder = match "multi" {
2322            "multi" => local_var_req_builder.query(
2323                &local_var_str
2324                    .into_iter()
2325                    .map(|p| ("description".to_owned(), p.to_string()))
2326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2327            ),
2328            _ => local_var_req_builder.query(&[(
2329                "description",
2330                &local_var_str
2331                    .into_iter()
2332                    .map(|p| p.to_string())
2333                    .collect::<Vec<String>>()
2334                    .join(",")
2335                    .to_string(),
2336            )]),
2337        };
2338    }
2339    if let Some(ref local_var_str) = description__empty {
2340        local_var_req_builder =
2341            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2342    }
2343    if let Some(ref local_var_str) = description__ic {
2344        local_var_req_builder = match "multi" {
2345            "multi" => local_var_req_builder.query(
2346                &local_var_str
2347                    .into_iter()
2348                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2350            ),
2351            _ => local_var_req_builder.query(&[(
2352                "description__ic",
2353                &local_var_str
2354                    .into_iter()
2355                    .map(|p| p.to_string())
2356                    .collect::<Vec<String>>()
2357                    .join(",")
2358                    .to_string(),
2359            )]),
2360        };
2361    }
2362    if let Some(ref local_var_str) = description__ie {
2363        local_var_req_builder = match "multi" {
2364            "multi" => local_var_req_builder.query(
2365                &local_var_str
2366                    .into_iter()
2367                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2369            ),
2370            _ => local_var_req_builder.query(&[(
2371                "description__ie",
2372                &local_var_str
2373                    .into_iter()
2374                    .map(|p| p.to_string())
2375                    .collect::<Vec<String>>()
2376                    .join(",")
2377                    .to_string(),
2378            )]),
2379        };
2380    }
2381    if let Some(ref local_var_str) = description__iew {
2382        local_var_req_builder = match "multi" {
2383            "multi" => local_var_req_builder.query(
2384                &local_var_str
2385                    .into_iter()
2386                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2388            ),
2389            _ => local_var_req_builder.query(&[(
2390                "description__iew",
2391                &local_var_str
2392                    .into_iter()
2393                    .map(|p| p.to_string())
2394                    .collect::<Vec<String>>()
2395                    .join(",")
2396                    .to_string(),
2397            )]),
2398        };
2399    }
2400    if let Some(ref local_var_str) = description__iregex {
2401        local_var_req_builder = match "multi" {
2402            "multi" => local_var_req_builder.query(
2403                &local_var_str
2404                    .into_iter()
2405                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2407            ),
2408            _ => local_var_req_builder.query(&[(
2409                "description__iregex",
2410                &local_var_str
2411                    .into_iter()
2412                    .map(|p| p.to_string())
2413                    .collect::<Vec<String>>()
2414                    .join(",")
2415                    .to_string(),
2416            )]),
2417        };
2418    }
2419    if let Some(ref local_var_str) = description__isw {
2420        local_var_req_builder = match "multi" {
2421            "multi" => local_var_req_builder.query(
2422                &local_var_str
2423                    .into_iter()
2424                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2426            ),
2427            _ => local_var_req_builder.query(&[(
2428                "description__isw",
2429                &local_var_str
2430                    .into_iter()
2431                    .map(|p| p.to_string())
2432                    .collect::<Vec<String>>()
2433                    .join(",")
2434                    .to_string(),
2435            )]),
2436        };
2437    }
2438    if let Some(ref local_var_str) = description__n {
2439        local_var_req_builder = match "multi" {
2440            "multi" => local_var_req_builder.query(
2441                &local_var_str
2442                    .into_iter()
2443                    .map(|p| ("description__n".to_owned(), p.to_string()))
2444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2445            ),
2446            _ => local_var_req_builder.query(&[(
2447                "description__n",
2448                &local_var_str
2449                    .into_iter()
2450                    .map(|p| p.to_string())
2451                    .collect::<Vec<String>>()
2452                    .join(",")
2453                    .to_string(),
2454            )]),
2455        };
2456    }
2457    if let Some(ref local_var_str) = description__nic {
2458        local_var_req_builder = match "multi" {
2459            "multi" => local_var_req_builder.query(
2460                &local_var_str
2461                    .into_iter()
2462                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2464            ),
2465            _ => local_var_req_builder.query(&[(
2466                "description__nic",
2467                &local_var_str
2468                    .into_iter()
2469                    .map(|p| p.to_string())
2470                    .collect::<Vec<String>>()
2471                    .join(",")
2472                    .to_string(),
2473            )]),
2474        };
2475    }
2476    if let Some(ref local_var_str) = description__nie {
2477        local_var_req_builder = match "multi" {
2478            "multi" => local_var_req_builder.query(
2479                &local_var_str
2480                    .into_iter()
2481                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2483            ),
2484            _ => local_var_req_builder.query(&[(
2485                "description__nie",
2486                &local_var_str
2487                    .into_iter()
2488                    .map(|p| p.to_string())
2489                    .collect::<Vec<String>>()
2490                    .join(",")
2491                    .to_string(),
2492            )]),
2493        };
2494    }
2495    if let Some(ref local_var_str) = description__niew {
2496        local_var_req_builder = match "multi" {
2497            "multi" => local_var_req_builder.query(
2498                &local_var_str
2499                    .into_iter()
2500                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2502            ),
2503            _ => local_var_req_builder.query(&[(
2504                "description__niew",
2505                &local_var_str
2506                    .into_iter()
2507                    .map(|p| p.to_string())
2508                    .collect::<Vec<String>>()
2509                    .join(",")
2510                    .to_string(),
2511            )]),
2512        };
2513    }
2514    if let Some(ref local_var_str) = description__nisw {
2515        local_var_req_builder = match "multi" {
2516            "multi" => local_var_req_builder.query(
2517                &local_var_str
2518                    .into_iter()
2519                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2521            ),
2522            _ => local_var_req_builder.query(&[(
2523                "description__nisw",
2524                &local_var_str
2525                    .into_iter()
2526                    .map(|p| p.to_string())
2527                    .collect::<Vec<String>>()
2528                    .join(",")
2529                    .to_string(),
2530            )]),
2531        };
2532    }
2533    if let Some(ref local_var_str) = description__regex {
2534        local_var_req_builder = match "multi" {
2535            "multi" => local_var_req_builder.query(
2536                &local_var_str
2537                    .into_iter()
2538                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2540            ),
2541            _ => local_var_req_builder.query(&[(
2542                "description__regex",
2543                &local_var_str
2544                    .into_iter()
2545                    .map(|p| p.to_string())
2546                    .collect::<Vec<String>>()
2547                    .join(",")
2548                    .to_string(),
2549            )]),
2550        };
2551    }
2552    if let Some(ref local_var_str) = id {
2553        local_var_req_builder = match "multi" {
2554            "multi" => local_var_req_builder.query(
2555                &local_var_str
2556                    .into_iter()
2557                    .map(|p| ("id".to_owned(), p.to_string()))
2558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2559            ),
2560            _ => local_var_req_builder.query(&[(
2561                "id",
2562                &local_var_str
2563                    .into_iter()
2564                    .map(|p| p.to_string())
2565                    .collect::<Vec<String>>()
2566                    .join(",")
2567                    .to_string(),
2568            )]),
2569        };
2570    }
2571    if let Some(ref local_var_str) = id__empty {
2572        local_var_req_builder =
2573            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2574    }
2575    if let Some(ref local_var_str) = id__gt {
2576        local_var_req_builder = match "multi" {
2577            "multi" => local_var_req_builder.query(
2578                &local_var_str
2579                    .into_iter()
2580                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2582            ),
2583            _ => local_var_req_builder.query(&[(
2584                "id__gt",
2585                &local_var_str
2586                    .into_iter()
2587                    .map(|p| p.to_string())
2588                    .collect::<Vec<String>>()
2589                    .join(",")
2590                    .to_string(),
2591            )]),
2592        };
2593    }
2594    if let Some(ref local_var_str) = id__gte {
2595        local_var_req_builder = match "multi" {
2596            "multi" => local_var_req_builder.query(
2597                &local_var_str
2598                    .into_iter()
2599                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2601            ),
2602            _ => local_var_req_builder.query(&[(
2603                "id__gte",
2604                &local_var_str
2605                    .into_iter()
2606                    .map(|p| p.to_string())
2607                    .collect::<Vec<String>>()
2608                    .join(",")
2609                    .to_string(),
2610            )]),
2611        };
2612    }
2613    if let Some(ref local_var_str) = id__lt {
2614        local_var_req_builder = match "multi" {
2615            "multi" => local_var_req_builder.query(
2616                &local_var_str
2617                    .into_iter()
2618                    .map(|p| ("id__lt".to_owned(), p.to_string()))
2619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2620            ),
2621            _ => local_var_req_builder.query(&[(
2622                "id__lt",
2623                &local_var_str
2624                    .into_iter()
2625                    .map(|p| p.to_string())
2626                    .collect::<Vec<String>>()
2627                    .join(",")
2628                    .to_string(),
2629            )]),
2630        };
2631    }
2632    if let Some(ref local_var_str) = id__lte {
2633        local_var_req_builder = match "multi" {
2634            "multi" => local_var_req_builder.query(
2635                &local_var_str
2636                    .into_iter()
2637                    .map(|p| ("id__lte".to_owned(), p.to_string()))
2638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2639            ),
2640            _ => local_var_req_builder.query(&[(
2641                "id__lte",
2642                &local_var_str
2643                    .into_iter()
2644                    .map(|p| p.to_string())
2645                    .collect::<Vec<String>>()
2646                    .join(",")
2647                    .to_string(),
2648            )]),
2649        };
2650    }
2651    if let Some(ref local_var_str) = id__n {
2652        local_var_req_builder = match "multi" {
2653            "multi" => local_var_req_builder.query(
2654                &local_var_str
2655                    .into_iter()
2656                    .map(|p| ("id__n".to_owned(), p.to_string()))
2657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2658            ),
2659            _ => local_var_req_builder.query(&[(
2660                "id__n",
2661                &local_var_str
2662                    .into_iter()
2663                    .map(|p| p.to_string())
2664                    .collect::<Vec<String>>()
2665                    .join(",")
2666                    .to_string(),
2667            )]),
2668        };
2669    }
2670    if let Some(ref local_var_str) = last_updated {
2671        local_var_req_builder = match "multi" {
2672            "multi" => local_var_req_builder.query(
2673                &local_var_str
2674                    .into_iter()
2675                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2677            ),
2678            _ => local_var_req_builder.query(&[(
2679                "last_updated",
2680                &local_var_str
2681                    .into_iter()
2682                    .map(|p| p.to_string())
2683                    .collect::<Vec<String>>()
2684                    .join(",")
2685                    .to_string(),
2686            )]),
2687        };
2688    }
2689    if let Some(ref local_var_str) = last_updated__empty {
2690        local_var_req_builder = match "multi" {
2691            "multi" => local_var_req_builder.query(
2692                &local_var_str
2693                    .into_iter()
2694                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
2695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2696            ),
2697            _ => local_var_req_builder.query(&[(
2698                "last_updated__empty",
2699                &local_var_str
2700                    .into_iter()
2701                    .map(|p| p.to_string())
2702                    .collect::<Vec<String>>()
2703                    .join(",")
2704                    .to_string(),
2705            )]),
2706        };
2707    }
2708    if let Some(ref local_var_str) = last_updated__gt {
2709        local_var_req_builder = match "multi" {
2710            "multi" => local_var_req_builder.query(
2711                &local_var_str
2712                    .into_iter()
2713                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
2714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2715            ),
2716            _ => local_var_req_builder.query(&[(
2717                "last_updated__gt",
2718                &local_var_str
2719                    .into_iter()
2720                    .map(|p| p.to_string())
2721                    .collect::<Vec<String>>()
2722                    .join(",")
2723                    .to_string(),
2724            )]),
2725        };
2726    }
2727    if let Some(ref local_var_str) = last_updated__gte {
2728        local_var_req_builder = match "multi" {
2729            "multi" => local_var_req_builder.query(
2730                &local_var_str
2731                    .into_iter()
2732                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
2733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2734            ),
2735            _ => local_var_req_builder.query(&[(
2736                "last_updated__gte",
2737                &local_var_str
2738                    .into_iter()
2739                    .map(|p| p.to_string())
2740                    .collect::<Vec<String>>()
2741                    .join(",")
2742                    .to_string(),
2743            )]),
2744        };
2745    }
2746    if let Some(ref local_var_str) = last_updated__lt {
2747        local_var_req_builder = match "multi" {
2748            "multi" => local_var_req_builder.query(
2749                &local_var_str
2750                    .into_iter()
2751                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
2752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2753            ),
2754            _ => local_var_req_builder.query(&[(
2755                "last_updated__lt",
2756                &local_var_str
2757                    .into_iter()
2758                    .map(|p| p.to_string())
2759                    .collect::<Vec<String>>()
2760                    .join(",")
2761                    .to_string(),
2762            )]),
2763        };
2764    }
2765    if let Some(ref local_var_str) = last_updated__lte {
2766        local_var_req_builder = match "multi" {
2767            "multi" => local_var_req_builder.query(
2768                &local_var_str
2769                    .into_iter()
2770                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
2771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2772            ),
2773            _ => local_var_req_builder.query(&[(
2774                "last_updated__lte",
2775                &local_var_str
2776                    .into_iter()
2777                    .map(|p| p.to_string())
2778                    .collect::<Vec<String>>()
2779                    .join(",")
2780                    .to_string(),
2781            )]),
2782        };
2783    }
2784    if let Some(ref local_var_str) = last_updated__n {
2785        local_var_req_builder = match "multi" {
2786            "multi" => local_var_req_builder.query(
2787                &local_var_str
2788                    .into_iter()
2789                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
2790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2791            ),
2792            _ => local_var_req_builder.query(&[(
2793                "last_updated__n",
2794                &local_var_str
2795                    .into_iter()
2796                    .map(|p| p.to_string())
2797                    .collect::<Vec<String>>()
2798                    .join(",")
2799                    .to_string(),
2800            )]),
2801        };
2802    }
2803    if let Some(ref local_var_str) = limit {
2804        local_var_req_builder =
2805            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
2806    }
2807    if let Some(ref local_var_str) = modified_by_request {
2808        local_var_req_builder =
2809            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
2810    }
2811    if let Some(ref local_var_str) = name {
2812        local_var_req_builder = match "multi" {
2813            "multi" => local_var_req_builder.query(
2814                &local_var_str
2815                    .into_iter()
2816                    .map(|p| ("name".to_owned(), p.to_string()))
2817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2818            ),
2819            _ => local_var_req_builder.query(&[(
2820                "name",
2821                &local_var_str
2822                    .into_iter()
2823                    .map(|p| p.to_string())
2824                    .collect::<Vec<String>>()
2825                    .join(",")
2826                    .to_string(),
2827            )]),
2828        };
2829    }
2830    if let Some(ref local_var_str) = name__empty {
2831        local_var_req_builder =
2832            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
2833    }
2834    if let Some(ref local_var_str) = name__ic {
2835        local_var_req_builder = match "multi" {
2836            "multi" => local_var_req_builder.query(
2837                &local_var_str
2838                    .into_iter()
2839                    .map(|p| ("name__ic".to_owned(), p.to_string()))
2840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2841            ),
2842            _ => local_var_req_builder.query(&[(
2843                "name__ic",
2844                &local_var_str
2845                    .into_iter()
2846                    .map(|p| p.to_string())
2847                    .collect::<Vec<String>>()
2848                    .join(",")
2849                    .to_string(),
2850            )]),
2851        };
2852    }
2853    if let Some(ref local_var_str) = name__ie {
2854        local_var_req_builder = match "multi" {
2855            "multi" => local_var_req_builder.query(
2856                &local_var_str
2857                    .into_iter()
2858                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2860            ),
2861            _ => local_var_req_builder.query(&[(
2862                "name__ie",
2863                &local_var_str
2864                    .into_iter()
2865                    .map(|p| p.to_string())
2866                    .collect::<Vec<String>>()
2867                    .join(",")
2868                    .to_string(),
2869            )]),
2870        };
2871    }
2872    if let Some(ref local_var_str) = name__iew {
2873        local_var_req_builder = match "multi" {
2874            "multi" => local_var_req_builder.query(
2875                &local_var_str
2876                    .into_iter()
2877                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2879            ),
2880            _ => local_var_req_builder.query(&[(
2881                "name__iew",
2882                &local_var_str
2883                    .into_iter()
2884                    .map(|p| p.to_string())
2885                    .collect::<Vec<String>>()
2886                    .join(",")
2887                    .to_string(),
2888            )]),
2889        };
2890    }
2891    if let Some(ref local_var_str) = name__iregex {
2892        local_var_req_builder = match "multi" {
2893            "multi" => local_var_req_builder.query(
2894                &local_var_str
2895                    .into_iter()
2896                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
2897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2898            ),
2899            _ => local_var_req_builder.query(&[(
2900                "name__iregex",
2901                &local_var_str
2902                    .into_iter()
2903                    .map(|p| p.to_string())
2904                    .collect::<Vec<String>>()
2905                    .join(",")
2906                    .to_string(),
2907            )]),
2908        };
2909    }
2910    if let Some(ref local_var_str) = name__isw {
2911        local_var_req_builder = match "multi" {
2912            "multi" => local_var_req_builder.query(
2913                &local_var_str
2914                    .into_iter()
2915                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2917            ),
2918            _ => local_var_req_builder.query(&[(
2919                "name__isw",
2920                &local_var_str
2921                    .into_iter()
2922                    .map(|p| p.to_string())
2923                    .collect::<Vec<String>>()
2924                    .join(",")
2925                    .to_string(),
2926            )]),
2927        };
2928    }
2929    if let Some(ref local_var_str) = name__n {
2930        local_var_req_builder = match "multi" {
2931            "multi" => local_var_req_builder.query(
2932                &local_var_str
2933                    .into_iter()
2934                    .map(|p| ("name__n".to_owned(), p.to_string()))
2935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2936            ),
2937            _ => local_var_req_builder.query(&[(
2938                "name__n",
2939                &local_var_str
2940                    .into_iter()
2941                    .map(|p| p.to_string())
2942                    .collect::<Vec<String>>()
2943                    .join(",")
2944                    .to_string(),
2945            )]),
2946        };
2947    }
2948    if let Some(ref local_var_str) = name__nic {
2949        local_var_req_builder = match "multi" {
2950            "multi" => local_var_req_builder.query(
2951                &local_var_str
2952                    .into_iter()
2953                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2955            ),
2956            _ => local_var_req_builder.query(&[(
2957                "name__nic",
2958                &local_var_str
2959                    .into_iter()
2960                    .map(|p| p.to_string())
2961                    .collect::<Vec<String>>()
2962                    .join(",")
2963                    .to_string(),
2964            )]),
2965        };
2966    }
2967    if let Some(ref local_var_str) = name__nie {
2968        local_var_req_builder = match "multi" {
2969            "multi" => local_var_req_builder.query(
2970                &local_var_str
2971                    .into_iter()
2972                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2974            ),
2975            _ => local_var_req_builder.query(&[(
2976                "name__nie",
2977                &local_var_str
2978                    .into_iter()
2979                    .map(|p| p.to_string())
2980                    .collect::<Vec<String>>()
2981                    .join(",")
2982                    .to_string(),
2983            )]),
2984        };
2985    }
2986    if let Some(ref local_var_str) = name__niew {
2987        local_var_req_builder = match "multi" {
2988            "multi" => local_var_req_builder.query(
2989                &local_var_str
2990                    .into_iter()
2991                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2993            ),
2994            _ => local_var_req_builder.query(&[(
2995                "name__niew",
2996                &local_var_str
2997                    .into_iter()
2998                    .map(|p| p.to_string())
2999                    .collect::<Vec<String>>()
3000                    .join(",")
3001                    .to_string(),
3002            )]),
3003        };
3004    }
3005    if let Some(ref local_var_str) = name__nisw {
3006        local_var_req_builder = match "multi" {
3007            "multi" => local_var_req_builder.query(
3008                &local_var_str
3009                    .into_iter()
3010                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3012            ),
3013            _ => local_var_req_builder.query(&[(
3014                "name__nisw",
3015                &local_var_str
3016                    .into_iter()
3017                    .map(|p| p.to_string())
3018                    .collect::<Vec<String>>()
3019                    .join(",")
3020                    .to_string(),
3021            )]),
3022        };
3023    }
3024    if let Some(ref local_var_str) = name__regex {
3025        local_var_req_builder = match "multi" {
3026            "multi" => local_var_req_builder.query(
3027                &local_var_str
3028                    .into_iter()
3029                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3031            ),
3032            _ => local_var_req_builder.query(&[(
3033                "name__regex",
3034                &local_var_str
3035                    .into_iter()
3036                    .map(|p| p.to_string())
3037                    .collect::<Vec<String>>()
3038                    .join(",")
3039                    .to_string(),
3040            )]),
3041        };
3042    }
3043    if let Some(ref local_var_str) = offset {
3044        local_var_req_builder =
3045            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3046    }
3047    if let Some(ref local_var_str) = ordering {
3048        local_var_req_builder =
3049            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3050    }
3051    if let Some(ref local_var_str) = parent {
3052        local_var_req_builder = match "multi" {
3053            "multi" => local_var_req_builder.query(
3054                &local_var_str
3055                    .into_iter()
3056                    .map(|p| ("parent".to_owned(), p.to_string()))
3057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3058            ),
3059            _ => local_var_req_builder.query(&[(
3060                "parent",
3061                &local_var_str
3062                    .into_iter()
3063                    .map(|p| p.to_string())
3064                    .collect::<Vec<String>>()
3065                    .join(",")
3066                    .to_string(),
3067            )]),
3068        };
3069    }
3070    if let Some(ref local_var_str) = parent__n {
3071        local_var_req_builder = match "multi" {
3072            "multi" => local_var_req_builder.query(
3073                &local_var_str
3074                    .into_iter()
3075                    .map(|p| ("parent__n".to_owned(), p.to_string()))
3076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3077            ),
3078            _ => local_var_req_builder.query(&[(
3079                "parent__n",
3080                &local_var_str
3081                    .into_iter()
3082                    .map(|p| p.to_string())
3083                    .collect::<Vec<String>>()
3084                    .join(",")
3085                    .to_string(),
3086            )]),
3087        };
3088    }
3089    if let Some(ref local_var_str) = parent_id {
3090        local_var_req_builder = match "multi" {
3091            "multi" => local_var_req_builder.query(
3092                &local_var_str
3093                    .into_iter()
3094                    .map(|p| ("parent_id".to_owned(), p.to_string()))
3095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3096            ),
3097            _ => local_var_req_builder.query(&[(
3098                "parent_id",
3099                &local_var_str
3100                    .into_iter()
3101                    .map(|p| p.to_string())
3102                    .collect::<Vec<String>>()
3103                    .join(",")
3104                    .to_string(),
3105            )]),
3106        };
3107    }
3108    if let Some(ref local_var_str) = parent_id__n {
3109        local_var_req_builder = match "multi" {
3110            "multi" => local_var_req_builder.query(
3111                &local_var_str
3112                    .into_iter()
3113                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
3114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3115            ),
3116            _ => local_var_req_builder.query(&[(
3117                "parent_id__n",
3118                &local_var_str
3119                    .into_iter()
3120                    .map(|p| p.to_string())
3121                    .collect::<Vec<String>>()
3122                    .join(",")
3123                    .to_string(),
3124            )]),
3125        };
3126    }
3127    if let Some(ref local_var_str) = q {
3128        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3129    }
3130    if let Some(ref local_var_str) = slug {
3131        local_var_req_builder = match "multi" {
3132            "multi" => local_var_req_builder.query(
3133                &local_var_str
3134                    .into_iter()
3135                    .map(|p| ("slug".to_owned(), p.to_string()))
3136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3137            ),
3138            _ => local_var_req_builder.query(&[(
3139                "slug",
3140                &local_var_str
3141                    .into_iter()
3142                    .map(|p| p.to_string())
3143                    .collect::<Vec<String>>()
3144                    .join(",")
3145                    .to_string(),
3146            )]),
3147        };
3148    }
3149    if let Some(ref local_var_str) = slug__empty {
3150        local_var_req_builder =
3151            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3152    }
3153    if let Some(ref local_var_str) = slug__ic {
3154        local_var_req_builder = match "multi" {
3155            "multi" => local_var_req_builder.query(
3156                &local_var_str
3157                    .into_iter()
3158                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3160            ),
3161            _ => local_var_req_builder.query(&[(
3162                "slug__ic",
3163                &local_var_str
3164                    .into_iter()
3165                    .map(|p| p.to_string())
3166                    .collect::<Vec<String>>()
3167                    .join(",")
3168                    .to_string(),
3169            )]),
3170        };
3171    }
3172    if let Some(ref local_var_str) = slug__ie {
3173        local_var_req_builder = match "multi" {
3174            "multi" => local_var_req_builder.query(
3175                &local_var_str
3176                    .into_iter()
3177                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3179            ),
3180            _ => local_var_req_builder.query(&[(
3181                "slug__ie",
3182                &local_var_str
3183                    .into_iter()
3184                    .map(|p| p.to_string())
3185                    .collect::<Vec<String>>()
3186                    .join(",")
3187                    .to_string(),
3188            )]),
3189        };
3190    }
3191    if let Some(ref local_var_str) = slug__iew {
3192        local_var_req_builder = match "multi" {
3193            "multi" => local_var_req_builder.query(
3194                &local_var_str
3195                    .into_iter()
3196                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3198            ),
3199            _ => local_var_req_builder.query(&[(
3200                "slug__iew",
3201                &local_var_str
3202                    .into_iter()
3203                    .map(|p| p.to_string())
3204                    .collect::<Vec<String>>()
3205                    .join(",")
3206                    .to_string(),
3207            )]),
3208        };
3209    }
3210    if let Some(ref local_var_str) = slug__iregex {
3211        local_var_req_builder = match "multi" {
3212            "multi" => local_var_req_builder.query(
3213                &local_var_str
3214                    .into_iter()
3215                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3217            ),
3218            _ => local_var_req_builder.query(&[(
3219                "slug__iregex",
3220                &local_var_str
3221                    .into_iter()
3222                    .map(|p| p.to_string())
3223                    .collect::<Vec<String>>()
3224                    .join(",")
3225                    .to_string(),
3226            )]),
3227        };
3228    }
3229    if let Some(ref local_var_str) = slug__isw {
3230        local_var_req_builder = match "multi" {
3231            "multi" => local_var_req_builder.query(
3232                &local_var_str
3233                    .into_iter()
3234                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3236            ),
3237            _ => local_var_req_builder.query(&[(
3238                "slug__isw",
3239                &local_var_str
3240                    .into_iter()
3241                    .map(|p| p.to_string())
3242                    .collect::<Vec<String>>()
3243                    .join(",")
3244                    .to_string(),
3245            )]),
3246        };
3247    }
3248    if let Some(ref local_var_str) = slug__n {
3249        local_var_req_builder = match "multi" {
3250            "multi" => local_var_req_builder.query(
3251                &local_var_str
3252                    .into_iter()
3253                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3255            ),
3256            _ => local_var_req_builder.query(&[(
3257                "slug__n",
3258                &local_var_str
3259                    .into_iter()
3260                    .map(|p| p.to_string())
3261                    .collect::<Vec<String>>()
3262                    .join(",")
3263                    .to_string(),
3264            )]),
3265        };
3266    }
3267    if let Some(ref local_var_str) = slug__nic {
3268        local_var_req_builder = match "multi" {
3269            "multi" => local_var_req_builder.query(
3270                &local_var_str
3271                    .into_iter()
3272                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3274            ),
3275            _ => local_var_req_builder.query(&[(
3276                "slug__nic",
3277                &local_var_str
3278                    .into_iter()
3279                    .map(|p| p.to_string())
3280                    .collect::<Vec<String>>()
3281                    .join(",")
3282                    .to_string(),
3283            )]),
3284        };
3285    }
3286    if let Some(ref local_var_str) = slug__nie {
3287        local_var_req_builder = match "multi" {
3288            "multi" => local_var_req_builder.query(
3289                &local_var_str
3290                    .into_iter()
3291                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3293            ),
3294            _ => local_var_req_builder.query(&[(
3295                "slug__nie",
3296                &local_var_str
3297                    .into_iter()
3298                    .map(|p| p.to_string())
3299                    .collect::<Vec<String>>()
3300                    .join(",")
3301                    .to_string(),
3302            )]),
3303        };
3304    }
3305    if let Some(ref local_var_str) = slug__niew {
3306        local_var_req_builder = match "multi" {
3307            "multi" => local_var_req_builder.query(
3308                &local_var_str
3309                    .into_iter()
3310                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3312            ),
3313            _ => local_var_req_builder.query(&[(
3314                "slug__niew",
3315                &local_var_str
3316                    .into_iter()
3317                    .map(|p| p.to_string())
3318                    .collect::<Vec<String>>()
3319                    .join(",")
3320                    .to_string(),
3321            )]),
3322        };
3323    }
3324    if let Some(ref local_var_str) = slug__nisw {
3325        local_var_req_builder = match "multi" {
3326            "multi" => local_var_req_builder.query(
3327                &local_var_str
3328                    .into_iter()
3329                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3331            ),
3332            _ => local_var_req_builder.query(&[(
3333                "slug__nisw",
3334                &local_var_str
3335                    .into_iter()
3336                    .map(|p| p.to_string())
3337                    .collect::<Vec<String>>()
3338                    .join(",")
3339                    .to_string(),
3340            )]),
3341        };
3342    }
3343    if let Some(ref local_var_str) = slug__regex {
3344        local_var_req_builder = match "multi" {
3345            "multi" => local_var_req_builder.query(
3346                &local_var_str
3347                    .into_iter()
3348                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3350            ),
3351            _ => local_var_req_builder.query(&[(
3352                "slug__regex",
3353                &local_var_str
3354                    .into_iter()
3355                    .map(|p| p.to_string())
3356                    .collect::<Vec<String>>()
3357                    .join(",")
3358                    .to_string(),
3359            )]),
3360        };
3361    }
3362    if let Some(ref local_var_str) = tag {
3363        local_var_req_builder = match "multi" {
3364            "multi" => local_var_req_builder.query(
3365                &local_var_str
3366                    .into_iter()
3367                    .map(|p| ("tag".to_owned(), p.to_string()))
3368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3369            ),
3370            _ => local_var_req_builder.query(&[(
3371                "tag",
3372                &local_var_str
3373                    .into_iter()
3374                    .map(|p| p.to_string())
3375                    .collect::<Vec<String>>()
3376                    .join(",")
3377                    .to_string(),
3378            )]),
3379        };
3380    }
3381    if let Some(ref local_var_str) = tag__n {
3382        local_var_req_builder = match "multi" {
3383            "multi" => local_var_req_builder.query(
3384                &local_var_str
3385                    .into_iter()
3386                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3388            ),
3389            _ => local_var_req_builder.query(&[(
3390                "tag__n",
3391                &local_var_str
3392                    .into_iter()
3393                    .map(|p| p.to_string())
3394                    .collect::<Vec<String>>()
3395                    .join(",")
3396                    .to_string(),
3397            )]),
3398        };
3399    }
3400    if let Some(ref local_var_str) = tag_id {
3401        local_var_req_builder = match "multi" {
3402            "multi" => local_var_req_builder.query(
3403                &local_var_str
3404                    .into_iter()
3405                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3407            ),
3408            _ => local_var_req_builder.query(&[(
3409                "tag_id",
3410                &local_var_str
3411                    .into_iter()
3412                    .map(|p| p.to_string())
3413                    .collect::<Vec<String>>()
3414                    .join(",")
3415                    .to_string(),
3416            )]),
3417        };
3418    }
3419    if let Some(ref local_var_str) = tag_id__n {
3420        local_var_req_builder = match "multi" {
3421            "multi" => local_var_req_builder.query(
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3426            ),
3427            _ => local_var_req_builder.query(&[(
3428                "tag_id__n",
3429                &local_var_str
3430                    .into_iter()
3431                    .map(|p| p.to_string())
3432                    .collect::<Vec<String>>()
3433                    .join(",")
3434                    .to_string(),
3435            )]),
3436        };
3437    }
3438    if let Some(ref local_var_str) = updated_by_request {
3439        local_var_req_builder =
3440            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
3441    }
3442    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3443        local_var_req_builder =
3444            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3445    }
3446    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3447        let local_var_key = local_var_apikey.key.clone();
3448        let local_var_value = match local_var_apikey.prefix {
3449            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3450            None => local_var_key,
3451        };
3452        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3453    };
3454
3455    let local_var_req = local_var_req_builder.build()?;
3456    let local_var_resp = local_var_client.execute(local_var_req).await?;
3457
3458    let local_var_status = local_var_resp.status();
3459    let local_var_content = local_var_resp.text().await?;
3460
3461    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3462        serde_json::from_str(&local_var_content).map_err(Error::from)
3463    } else {
3464        let local_var_entity: Option<TenancyContactGroupsListError> =
3465            serde_json::from_str(&local_var_content).ok();
3466        let local_var_error = ResponseContent {
3467            status: local_var_status,
3468            content: local_var_content,
3469            entity: local_var_entity,
3470        };
3471        Err(Error::ResponseError(local_var_error))
3472    }
3473}
3474
3475/// Patch a contact group object.
3476pub async fn tenancy_contact_groups_partial_update(
3477    configuration: &configuration::Configuration,
3478    id: i32,
3479    patched_writable_contact_group_request: Option<
3480        crate::models::PatchedWritableContactGroupRequest,
3481    >,
3482) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsPartialUpdateError>> {
3483    let local_var_configuration = configuration;
3484
3485    let local_var_client = &local_var_configuration.client;
3486
3487    let local_var_uri_str = format!(
3488        "{}/api/tenancy/contact-groups/{id}/",
3489        local_var_configuration.base_path,
3490        id = id
3491    );
3492    let mut local_var_req_builder =
3493        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3494
3495    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3496        local_var_req_builder =
3497            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3498    }
3499    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3500        let local_var_key = local_var_apikey.key.clone();
3501        let local_var_value = match local_var_apikey.prefix {
3502            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3503            None => local_var_key,
3504        };
3505        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3506    };
3507    local_var_req_builder = local_var_req_builder.json(&patched_writable_contact_group_request);
3508
3509    let local_var_req = local_var_req_builder.build()?;
3510    let local_var_resp = local_var_client.execute(local_var_req).await?;
3511
3512    let local_var_status = local_var_resp.status();
3513    let local_var_content = local_var_resp.text().await?;
3514
3515    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3516        serde_json::from_str(&local_var_content).map_err(Error::from)
3517    } else {
3518        let local_var_entity: Option<TenancyContactGroupsPartialUpdateError> =
3519            serde_json::from_str(&local_var_content).ok();
3520        let local_var_error = ResponseContent {
3521            status: local_var_status,
3522            content: local_var_content,
3523            entity: local_var_entity,
3524        };
3525        Err(Error::ResponseError(local_var_error))
3526    }
3527}
3528
3529/// Get a contact group object.
3530pub async fn tenancy_contact_groups_retrieve(
3531    configuration: &configuration::Configuration,
3532    id: i32,
3533) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsRetrieveError>> {
3534    let local_var_configuration = configuration;
3535
3536    let local_var_client = &local_var_configuration.client;
3537
3538    let local_var_uri_str = format!(
3539        "{}/api/tenancy/contact-groups/{id}/",
3540        local_var_configuration.base_path,
3541        id = id
3542    );
3543    let mut local_var_req_builder =
3544        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3545
3546    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3547        local_var_req_builder =
3548            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3549    }
3550    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3551        let local_var_key = local_var_apikey.key.clone();
3552        let local_var_value = match local_var_apikey.prefix {
3553            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3554            None => local_var_key,
3555        };
3556        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3557    };
3558
3559    let local_var_req = local_var_req_builder.build()?;
3560    let local_var_resp = local_var_client.execute(local_var_req).await?;
3561
3562    let local_var_status = local_var_resp.status();
3563    let local_var_content = local_var_resp.text().await?;
3564
3565    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3566        serde_json::from_str(&local_var_content).map_err(Error::from)
3567    } else {
3568        let local_var_entity: Option<TenancyContactGroupsRetrieveError> =
3569            serde_json::from_str(&local_var_content).ok();
3570        let local_var_error = ResponseContent {
3571            status: local_var_status,
3572            content: local_var_content,
3573            entity: local_var_entity,
3574        };
3575        Err(Error::ResponseError(local_var_error))
3576    }
3577}
3578
3579/// Put a contact group object.
3580pub async fn tenancy_contact_groups_update(
3581    configuration: &configuration::Configuration,
3582    id: i32,
3583    writable_contact_group_request: crate::models::WritableContactGroupRequest,
3584) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsUpdateError>> {
3585    let local_var_configuration = configuration;
3586
3587    let local_var_client = &local_var_configuration.client;
3588
3589    let local_var_uri_str = format!(
3590        "{}/api/tenancy/contact-groups/{id}/",
3591        local_var_configuration.base_path,
3592        id = id
3593    );
3594    let mut local_var_req_builder =
3595        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3596
3597    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3598        local_var_req_builder =
3599            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3600    }
3601    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3602        let local_var_key = local_var_apikey.key.clone();
3603        let local_var_value = match local_var_apikey.prefix {
3604            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3605            None => local_var_key,
3606        };
3607        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3608    };
3609    local_var_req_builder = local_var_req_builder.json(&writable_contact_group_request);
3610
3611    let local_var_req = local_var_req_builder.build()?;
3612    let local_var_resp = local_var_client.execute(local_var_req).await?;
3613
3614    let local_var_status = local_var_resp.status();
3615    let local_var_content = local_var_resp.text().await?;
3616
3617    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3618        serde_json::from_str(&local_var_content).map_err(Error::from)
3619    } else {
3620        let local_var_entity: Option<TenancyContactGroupsUpdateError> =
3621            serde_json::from_str(&local_var_content).ok();
3622        let local_var_error = ResponseContent {
3623            status: local_var_status,
3624            content: local_var_content,
3625            entity: local_var_entity,
3626        };
3627        Err(Error::ResponseError(local_var_error))
3628    }
3629}
3630
3631/// Delete a list of contact role objects.
3632pub async fn tenancy_contact_roles_bulk_destroy(
3633    configuration: &configuration::Configuration,
3634    contact_role_request: Vec<crate::models::ContactRoleRequest>,
3635) -> Result<(), Error<TenancyContactRolesBulkDestroyError>> {
3636    let local_var_configuration = configuration;
3637
3638    let local_var_client = &local_var_configuration.client;
3639
3640    let local_var_uri_str = format!(
3641        "{}/api/tenancy/contact-roles/",
3642        local_var_configuration.base_path
3643    );
3644    let mut local_var_req_builder =
3645        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3646
3647    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3648        local_var_req_builder =
3649            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3650    }
3651    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3652        let local_var_key = local_var_apikey.key.clone();
3653        let local_var_value = match local_var_apikey.prefix {
3654            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3655            None => local_var_key,
3656        };
3657        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3658    };
3659    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
3660
3661    let local_var_req = local_var_req_builder.build()?;
3662    let local_var_resp = local_var_client.execute(local_var_req).await?;
3663
3664    let local_var_status = local_var_resp.status();
3665    let local_var_content = local_var_resp.text().await?;
3666
3667    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3668        Ok(())
3669    } else {
3670        let local_var_entity: Option<TenancyContactRolesBulkDestroyError> =
3671            serde_json::from_str(&local_var_content).ok();
3672        let local_var_error = ResponseContent {
3673            status: local_var_status,
3674            content: local_var_content,
3675            entity: local_var_entity,
3676        };
3677        Err(Error::ResponseError(local_var_error))
3678    }
3679}
3680
3681/// Patch a list of contact role objects.
3682pub async fn tenancy_contact_roles_bulk_partial_update(
3683    configuration: &configuration::Configuration,
3684    contact_role_request: Vec<crate::models::ContactRoleRequest>,
3685) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkPartialUpdateError>> {
3686    let local_var_configuration = configuration;
3687
3688    let local_var_client = &local_var_configuration.client;
3689
3690    let local_var_uri_str = format!(
3691        "{}/api/tenancy/contact-roles/",
3692        local_var_configuration.base_path
3693    );
3694    let mut local_var_req_builder =
3695        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3696
3697    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3698        local_var_req_builder =
3699            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3700    }
3701    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3702        let local_var_key = local_var_apikey.key.clone();
3703        let local_var_value = match local_var_apikey.prefix {
3704            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3705            None => local_var_key,
3706        };
3707        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3708    };
3709    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
3710
3711    let local_var_req = local_var_req_builder.build()?;
3712    let local_var_resp = local_var_client.execute(local_var_req).await?;
3713
3714    let local_var_status = local_var_resp.status();
3715    let local_var_content = local_var_resp.text().await?;
3716
3717    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3718        serde_json::from_str(&local_var_content).map_err(Error::from)
3719    } else {
3720        let local_var_entity: Option<TenancyContactRolesBulkPartialUpdateError> =
3721            serde_json::from_str(&local_var_content).ok();
3722        let local_var_error = ResponseContent {
3723            status: local_var_status,
3724            content: local_var_content,
3725            entity: local_var_entity,
3726        };
3727        Err(Error::ResponseError(local_var_error))
3728    }
3729}
3730
3731/// Put a list of contact role objects.
3732pub async fn tenancy_contact_roles_bulk_update(
3733    configuration: &configuration::Configuration,
3734    contact_role_request: Vec<crate::models::ContactRoleRequest>,
3735) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkUpdateError>> {
3736    let local_var_configuration = configuration;
3737
3738    let local_var_client = &local_var_configuration.client;
3739
3740    let local_var_uri_str = format!(
3741        "{}/api/tenancy/contact-roles/",
3742        local_var_configuration.base_path
3743    );
3744    let mut local_var_req_builder =
3745        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3746
3747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3748        local_var_req_builder =
3749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3750    }
3751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3752        let local_var_key = local_var_apikey.key.clone();
3753        let local_var_value = match local_var_apikey.prefix {
3754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3755            None => local_var_key,
3756        };
3757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3758    };
3759    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
3760
3761    let local_var_req = local_var_req_builder.build()?;
3762    let local_var_resp = local_var_client.execute(local_var_req).await?;
3763
3764    let local_var_status = local_var_resp.status();
3765    let local_var_content = local_var_resp.text().await?;
3766
3767    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3768        serde_json::from_str(&local_var_content).map_err(Error::from)
3769    } else {
3770        let local_var_entity: Option<TenancyContactRolesBulkUpdateError> =
3771            serde_json::from_str(&local_var_content).ok();
3772        let local_var_error = ResponseContent {
3773            status: local_var_status,
3774            content: local_var_content,
3775            entity: local_var_entity,
3776        };
3777        Err(Error::ResponseError(local_var_error))
3778    }
3779}
3780
3781/// Post a list of contact role objects.
3782pub async fn tenancy_contact_roles_create(
3783    configuration: &configuration::Configuration,
3784    contact_role_request: crate::models::ContactRoleRequest,
3785) -> Result<crate::models::ContactRole, Error<TenancyContactRolesCreateError>> {
3786    let local_var_configuration = configuration;
3787
3788    let local_var_client = &local_var_configuration.client;
3789
3790    let local_var_uri_str = format!(
3791        "{}/api/tenancy/contact-roles/",
3792        local_var_configuration.base_path
3793    );
3794    let mut local_var_req_builder =
3795        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3796
3797    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3798        local_var_req_builder =
3799            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3800    }
3801    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3802        let local_var_key = local_var_apikey.key.clone();
3803        let local_var_value = match local_var_apikey.prefix {
3804            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3805            None => local_var_key,
3806        };
3807        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3808    };
3809    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
3810
3811    let local_var_req = local_var_req_builder.build()?;
3812    let local_var_resp = local_var_client.execute(local_var_req).await?;
3813
3814    let local_var_status = local_var_resp.status();
3815    let local_var_content = local_var_resp.text().await?;
3816
3817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3818        serde_json::from_str(&local_var_content).map_err(Error::from)
3819    } else {
3820        let local_var_entity: Option<TenancyContactRolesCreateError> =
3821            serde_json::from_str(&local_var_content).ok();
3822        let local_var_error = ResponseContent {
3823            status: local_var_status,
3824            content: local_var_content,
3825            entity: local_var_entity,
3826        };
3827        Err(Error::ResponseError(local_var_error))
3828    }
3829}
3830
3831/// Delete a contact role object.
3832pub async fn tenancy_contact_roles_destroy(
3833    configuration: &configuration::Configuration,
3834    id: i32,
3835) -> Result<(), Error<TenancyContactRolesDestroyError>> {
3836    let local_var_configuration = configuration;
3837
3838    let local_var_client = &local_var_configuration.client;
3839
3840    let local_var_uri_str = format!(
3841        "{}/api/tenancy/contact-roles/{id}/",
3842        local_var_configuration.base_path,
3843        id = id
3844    );
3845    let mut local_var_req_builder =
3846        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3847
3848    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3849        local_var_req_builder =
3850            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3851    }
3852    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3853        let local_var_key = local_var_apikey.key.clone();
3854        let local_var_value = match local_var_apikey.prefix {
3855            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3856            None => local_var_key,
3857        };
3858        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3859    };
3860
3861    let local_var_req = local_var_req_builder.build()?;
3862    let local_var_resp = local_var_client.execute(local_var_req).await?;
3863
3864    let local_var_status = local_var_resp.status();
3865    let local_var_content = local_var_resp.text().await?;
3866
3867    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3868        Ok(())
3869    } else {
3870        let local_var_entity: Option<TenancyContactRolesDestroyError> =
3871            serde_json::from_str(&local_var_content).ok();
3872        let local_var_error = ResponseContent {
3873            status: local_var_status,
3874            content: local_var_content,
3875            entity: local_var_entity,
3876        };
3877        Err(Error::ResponseError(local_var_error))
3878    }
3879}
3880
3881/// Get a list of contact role objects.
3882pub async fn tenancy_contact_roles_list(
3883    configuration: &configuration::Configuration,
3884    created: Option<Vec<String>>,
3885    created__empty: Option<Vec<String>>,
3886    created__gt: Option<Vec<String>>,
3887    created__gte: Option<Vec<String>>,
3888    created__lt: Option<Vec<String>>,
3889    created__lte: Option<Vec<String>>,
3890    created__n: Option<Vec<String>>,
3891    created_by_request: Option<&str>,
3892    description: Option<Vec<String>>,
3893    description__empty: Option<bool>,
3894    description__ic: Option<Vec<String>>,
3895    description__ie: Option<Vec<String>>,
3896    description__iew: Option<Vec<String>>,
3897    description__iregex: Option<Vec<String>>,
3898    description__isw: Option<Vec<String>>,
3899    description__n: Option<Vec<String>>,
3900    description__nic: Option<Vec<String>>,
3901    description__nie: Option<Vec<String>>,
3902    description__niew: Option<Vec<String>>,
3903    description__nisw: Option<Vec<String>>,
3904    description__regex: Option<Vec<String>>,
3905    id: Option<Vec<i32>>,
3906    id__empty: Option<bool>,
3907    id__gt: Option<Vec<i32>>,
3908    id__gte: Option<Vec<i32>>,
3909    id__lt: Option<Vec<i32>>,
3910    id__lte: Option<Vec<i32>>,
3911    id__n: Option<Vec<i32>>,
3912    last_updated: Option<Vec<String>>,
3913    last_updated__empty: Option<Vec<String>>,
3914    last_updated__gt: Option<Vec<String>>,
3915    last_updated__gte: Option<Vec<String>>,
3916    last_updated__lt: Option<Vec<String>>,
3917    last_updated__lte: Option<Vec<String>>,
3918    last_updated__n: Option<Vec<String>>,
3919    limit: Option<i32>,
3920    modified_by_request: Option<&str>,
3921    name: Option<Vec<String>>,
3922    name__empty: Option<bool>,
3923    name__ic: Option<Vec<String>>,
3924    name__ie: Option<Vec<String>>,
3925    name__iew: Option<Vec<String>>,
3926    name__iregex: Option<Vec<String>>,
3927    name__isw: Option<Vec<String>>,
3928    name__n: Option<Vec<String>>,
3929    name__nic: Option<Vec<String>>,
3930    name__nie: Option<Vec<String>>,
3931    name__niew: Option<Vec<String>>,
3932    name__nisw: Option<Vec<String>>,
3933    name__regex: Option<Vec<String>>,
3934    offset: Option<i32>,
3935    ordering: Option<&str>,
3936    q: Option<&str>,
3937    slug: Option<Vec<String>>,
3938    slug__empty: Option<bool>,
3939    slug__ic: Option<Vec<String>>,
3940    slug__ie: Option<Vec<String>>,
3941    slug__iew: Option<Vec<String>>,
3942    slug__iregex: Option<Vec<String>>,
3943    slug__isw: Option<Vec<String>>,
3944    slug__n: Option<Vec<String>>,
3945    slug__nic: Option<Vec<String>>,
3946    slug__nie: Option<Vec<String>>,
3947    slug__niew: Option<Vec<String>>,
3948    slug__nisw: Option<Vec<String>>,
3949    slug__regex: Option<Vec<String>>,
3950    tag: Option<Vec<String>>,
3951    tag__n: Option<Vec<String>>,
3952    tag_id: Option<Vec<i32>>,
3953    tag_id__n: Option<Vec<i32>>,
3954    updated_by_request: Option<&str>,
3955) -> Result<crate::models::PaginatedContactRoleList, Error<TenancyContactRolesListError>> {
3956    let local_var_configuration = configuration;
3957
3958    let local_var_client = &local_var_configuration.client;
3959
3960    let local_var_uri_str = format!(
3961        "{}/api/tenancy/contact-roles/",
3962        local_var_configuration.base_path
3963    );
3964    let mut local_var_req_builder =
3965        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3966
3967    if let Some(ref local_var_str) = created {
3968        local_var_req_builder = match "multi" {
3969            "multi" => local_var_req_builder.query(
3970                &local_var_str
3971                    .into_iter()
3972                    .map(|p| ("created".to_owned(), p.to_string()))
3973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3974            ),
3975            _ => local_var_req_builder.query(&[(
3976                "created",
3977                &local_var_str
3978                    .into_iter()
3979                    .map(|p| p.to_string())
3980                    .collect::<Vec<String>>()
3981                    .join(",")
3982                    .to_string(),
3983            )]),
3984        };
3985    }
3986    if let Some(ref local_var_str) = created__empty {
3987        local_var_req_builder = match "multi" {
3988            "multi" => local_var_req_builder.query(
3989                &local_var_str
3990                    .into_iter()
3991                    .map(|p| ("created__empty".to_owned(), p.to_string()))
3992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3993            ),
3994            _ => local_var_req_builder.query(&[(
3995                "created__empty",
3996                &local_var_str
3997                    .into_iter()
3998                    .map(|p| p.to_string())
3999                    .collect::<Vec<String>>()
4000                    .join(",")
4001                    .to_string(),
4002            )]),
4003        };
4004    }
4005    if let Some(ref local_var_str) = created__gt {
4006        local_var_req_builder = match "multi" {
4007            "multi" => local_var_req_builder.query(
4008                &local_var_str
4009                    .into_iter()
4010                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4012            ),
4013            _ => local_var_req_builder.query(&[(
4014                "created__gt",
4015                &local_var_str
4016                    .into_iter()
4017                    .map(|p| p.to_string())
4018                    .collect::<Vec<String>>()
4019                    .join(",")
4020                    .to_string(),
4021            )]),
4022        };
4023    }
4024    if let Some(ref local_var_str) = created__gte {
4025        local_var_req_builder = match "multi" {
4026            "multi" => local_var_req_builder.query(
4027                &local_var_str
4028                    .into_iter()
4029                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4031            ),
4032            _ => local_var_req_builder.query(&[(
4033                "created__gte",
4034                &local_var_str
4035                    .into_iter()
4036                    .map(|p| p.to_string())
4037                    .collect::<Vec<String>>()
4038                    .join(",")
4039                    .to_string(),
4040            )]),
4041        };
4042    }
4043    if let Some(ref local_var_str) = created__lt {
4044        local_var_req_builder = match "multi" {
4045            "multi" => local_var_req_builder.query(
4046                &local_var_str
4047                    .into_iter()
4048                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4050            ),
4051            _ => local_var_req_builder.query(&[(
4052                "created__lt",
4053                &local_var_str
4054                    .into_iter()
4055                    .map(|p| p.to_string())
4056                    .collect::<Vec<String>>()
4057                    .join(",")
4058                    .to_string(),
4059            )]),
4060        };
4061    }
4062    if let Some(ref local_var_str) = created__lte {
4063        local_var_req_builder = match "multi" {
4064            "multi" => local_var_req_builder.query(
4065                &local_var_str
4066                    .into_iter()
4067                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4069            ),
4070            _ => local_var_req_builder.query(&[(
4071                "created__lte",
4072                &local_var_str
4073                    .into_iter()
4074                    .map(|p| p.to_string())
4075                    .collect::<Vec<String>>()
4076                    .join(",")
4077                    .to_string(),
4078            )]),
4079        };
4080    }
4081    if let Some(ref local_var_str) = created__n {
4082        local_var_req_builder = match "multi" {
4083            "multi" => local_var_req_builder.query(
4084                &local_var_str
4085                    .into_iter()
4086                    .map(|p| ("created__n".to_owned(), p.to_string()))
4087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4088            ),
4089            _ => local_var_req_builder.query(&[(
4090                "created__n",
4091                &local_var_str
4092                    .into_iter()
4093                    .map(|p| p.to_string())
4094                    .collect::<Vec<String>>()
4095                    .join(",")
4096                    .to_string(),
4097            )]),
4098        };
4099    }
4100    if let Some(ref local_var_str) = created_by_request {
4101        local_var_req_builder =
4102            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4103    }
4104    if let Some(ref local_var_str) = description {
4105        local_var_req_builder = match "multi" {
4106            "multi" => local_var_req_builder.query(
4107                &local_var_str
4108                    .into_iter()
4109                    .map(|p| ("description".to_owned(), p.to_string()))
4110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4111            ),
4112            _ => local_var_req_builder.query(&[(
4113                "description",
4114                &local_var_str
4115                    .into_iter()
4116                    .map(|p| p.to_string())
4117                    .collect::<Vec<String>>()
4118                    .join(",")
4119                    .to_string(),
4120            )]),
4121        };
4122    }
4123    if let Some(ref local_var_str) = description__empty {
4124        local_var_req_builder =
4125            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4126    }
4127    if let Some(ref local_var_str) = description__ic {
4128        local_var_req_builder = match "multi" {
4129            "multi" => local_var_req_builder.query(
4130                &local_var_str
4131                    .into_iter()
4132                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4134            ),
4135            _ => local_var_req_builder.query(&[(
4136                "description__ic",
4137                &local_var_str
4138                    .into_iter()
4139                    .map(|p| p.to_string())
4140                    .collect::<Vec<String>>()
4141                    .join(",")
4142                    .to_string(),
4143            )]),
4144        };
4145    }
4146    if let Some(ref local_var_str) = description__ie {
4147        local_var_req_builder = match "multi" {
4148            "multi" => local_var_req_builder.query(
4149                &local_var_str
4150                    .into_iter()
4151                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4153            ),
4154            _ => local_var_req_builder.query(&[(
4155                "description__ie",
4156                &local_var_str
4157                    .into_iter()
4158                    .map(|p| p.to_string())
4159                    .collect::<Vec<String>>()
4160                    .join(",")
4161                    .to_string(),
4162            )]),
4163        };
4164    }
4165    if let Some(ref local_var_str) = description__iew {
4166        local_var_req_builder = match "multi" {
4167            "multi" => local_var_req_builder.query(
4168                &local_var_str
4169                    .into_iter()
4170                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4172            ),
4173            _ => local_var_req_builder.query(&[(
4174                "description__iew",
4175                &local_var_str
4176                    .into_iter()
4177                    .map(|p| p.to_string())
4178                    .collect::<Vec<String>>()
4179                    .join(",")
4180                    .to_string(),
4181            )]),
4182        };
4183    }
4184    if let Some(ref local_var_str) = description__iregex {
4185        local_var_req_builder = match "multi" {
4186            "multi" => local_var_req_builder.query(
4187                &local_var_str
4188                    .into_iter()
4189                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4191            ),
4192            _ => local_var_req_builder.query(&[(
4193                "description__iregex",
4194                &local_var_str
4195                    .into_iter()
4196                    .map(|p| p.to_string())
4197                    .collect::<Vec<String>>()
4198                    .join(",")
4199                    .to_string(),
4200            )]),
4201        };
4202    }
4203    if let Some(ref local_var_str) = description__isw {
4204        local_var_req_builder = match "multi" {
4205            "multi" => local_var_req_builder.query(
4206                &local_var_str
4207                    .into_iter()
4208                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4210            ),
4211            _ => local_var_req_builder.query(&[(
4212                "description__isw",
4213                &local_var_str
4214                    .into_iter()
4215                    .map(|p| p.to_string())
4216                    .collect::<Vec<String>>()
4217                    .join(",")
4218                    .to_string(),
4219            )]),
4220        };
4221    }
4222    if let Some(ref local_var_str) = description__n {
4223        local_var_req_builder = match "multi" {
4224            "multi" => local_var_req_builder.query(
4225                &local_var_str
4226                    .into_iter()
4227                    .map(|p| ("description__n".to_owned(), p.to_string()))
4228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4229            ),
4230            _ => local_var_req_builder.query(&[(
4231                "description__n",
4232                &local_var_str
4233                    .into_iter()
4234                    .map(|p| p.to_string())
4235                    .collect::<Vec<String>>()
4236                    .join(",")
4237                    .to_string(),
4238            )]),
4239        };
4240    }
4241    if let Some(ref local_var_str) = description__nic {
4242        local_var_req_builder = match "multi" {
4243            "multi" => local_var_req_builder.query(
4244                &local_var_str
4245                    .into_iter()
4246                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4248            ),
4249            _ => local_var_req_builder.query(&[(
4250                "description__nic",
4251                &local_var_str
4252                    .into_iter()
4253                    .map(|p| p.to_string())
4254                    .collect::<Vec<String>>()
4255                    .join(",")
4256                    .to_string(),
4257            )]),
4258        };
4259    }
4260    if let Some(ref local_var_str) = description__nie {
4261        local_var_req_builder = match "multi" {
4262            "multi" => local_var_req_builder.query(
4263                &local_var_str
4264                    .into_iter()
4265                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4267            ),
4268            _ => local_var_req_builder.query(&[(
4269                "description__nie",
4270                &local_var_str
4271                    .into_iter()
4272                    .map(|p| p.to_string())
4273                    .collect::<Vec<String>>()
4274                    .join(",")
4275                    .to_string(),
4276            )]),
4277        };
4278    }
4279    if let Some(ref local_var_str) = description__niew {
4280        local_var_req_builder = match "multi" {
4281            "multi" => local_var_req_builder.query(
4282                &local_var_str
4283                    .into_iter()
4284                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4286            ),
4287            _ => local_var_req_builder.query(&[(
4288                "description__niew",
4289                &local_var_str
4290                    .into_iter()
4291                    .map(|p| p.to_string())
4292                    .collect::<Vec<String>>()
4293                    .join(",")
4294                    .to_string(),
4295            )]),
4296        };
4297    }
4298    if let Some(ref local_var_str) = description__nisw {
4299        local_var_req_builder = match "multi" {
4300            "multi" => local_var_req_builder.query(
4301                &local_var_str
4302                    .into_iter()
4303                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4305            ),
4306            _ => local_var_req_builder.query(&[(
4307                "description__nisw",
4308                &local_var_str
4309                    .into_iter()
4310                    .map(|p| p.to_string())
4311                    .collect::<Vec<String>>()
4312                    .join(",")
4313                    .to_string(),
4314            )]),
4315        };
4316    }
4317    if let Some(ref local_var_str) = description__regex {
4318        local_var_req_builder = match "multi" {
4319            "multi" => local_var_req_builder.query(
4320                &local_var_str
4321                    .into_iter()
4322                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4324            ),
4325            _ => local_var_req_builder.query(&[(
4326                "description__regex",
4327                &local_var_str
4328                    .into_iter()
4329                    .map(|p| p.to_string())
4330                    .collect::<Vec<String>>()
4331                    .join(",")
4332                    .to_string(),
4333            )]),
4334        };
4335    }
4336    if let Some(ref local_var_str) = id {
4337        local_var_req_builder = match "multi" {
4338            "multi" => local_var_req_builder.query(
4339                &local_var_str
4340                    .into_iter()
4341                    .map(|p| ("id".to_owned(), p.to_string()))
4342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4343            ),
4344            _ => local_var_req_builder.query(&[(
4345                "id",
4346                &local_var_str
4347                    .into_iter()
4348                    .map(|p| p.to_string())
4349                    .collect::<Vec<String>>()
4350                    .join(",")
4351                    .to_string(),
4352            )]),
4353        };
4354    }
4355    if let Some(ref local_var_str) = id__empty {
4356        local_var_req_builder =
4357            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4358    }
4359    if let Some(ref local_var_str) = id__gt {
4360        local_var_req_builder = match "multi" {
4361            "multi" => local_var_req_builder.query(
4362                &local_var_str
4363                    .into_iter()
4364                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4366            ),
4367            _ => local_var_req_builder.query(&[(
4368                "id__gt",
4369                &local_var_str
4370                    .into_iter()
4371                    .map(|p| p.to_string())
4372                    .collect::<Vec<String>>()
4373                    .join(",")
4374                    .to_string(),
4375            )]),
4376        };
4377    }
4378    if let Some(ref local_var_str) = id__gte {
4379        local_var_req_builder = match "multi" {
4380            "multi" => local_var_req_builder.query(
4381                &local_var_str
4382                    .into_iter()
4383                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4385            ),
4386            _ => local_var_req_builder.query(&[(
4387                "id__gte",
4388                &local_var_str
4389                    .into_iter()
4390                    .map(|p| p.to_string())
4391                    .collect::<Vec<String>>()
4392                    .join(",")
4393                    .to_string(),
4394            )]),
4395        };
4396    }
4397    if let Some(ref local_var_str) = id__lt {
4398        local_var_req_builder = match "multi" {
4399            "multi" => local_var_req_builder.query(
4400                &local_var_str
4401                    .into_iter()
4402                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4404            ),
4405            _ => local_var_req_builder.query(&[(
4406                "id__lt",
4407                &local_var_str
4408                    .into_iter()
4409                    .map(|p| p.to_string())
4410                    .collect::<Vec<String>>()
4411                    .join(",")
4412                    .to_string(),
4413            )]),
4414        };
4415    }
4416    if let Some(ref local_var_str) = id__lte {
4417        local_var_req_builder = match "multi" {
4418            "multi" => local_var_req_builder.query(
4419                &local_var_str
4420                    .into_iter()
4421                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4423            ),
4424            _ => local_var_req_builder.query(&[(
4425                "id__lte",
4426                &local_var_str
4427                    .into_iter()
4428                    .map(|p| p.to_string())
4429                    .collect::<Vec<String>>()
4430                    .join(",")
4431                    .to_string(),
4432            )]),
4433        };
4434    }
4435    if let Some(ref local_var_str) = id__n {
4436        local_var_req_builder = match "multi" {
4437            "multi" => local_var_req_builder.query(
4438                &local_var_str
4439                    .into_iter()
4440                    .map(|p| ("id__n".to_owned(), p.to_string()))
4441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4442            ),
4443            _ => local_var_req_builder.query(&[(
4444                "id__n",
4445                &local_var_str
4446                    .into_iter()
4447                    .map(|p| p.to_string())
4448                    .collect::<Vec<String>>()
4449                    .join(",")
4450                    .to_string(),
4451            )]),
4452        };
4453    }
4454    if let Some(ref local_var_str) = last_updated {
4455        local_var_req_builder = match "multi" {
4456            "multi" => local_var_req_builder.query(
4457                &local_var_str
4458                    .into_iter()
4459                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4461            ),
4462            _ => local_var_req_builder.query(&[(
4463                "last_updated",
4464                &local_var_str
4465                    .into_iter()
4466                    .map(|p| p.to_string())
4467                    .collect::<Vec<String>>()
4468                    .join(",")
4469                    .to_string(),
4470            )]),
4471        };
4472    }
4473    if let Some(ref local_var_str) = last_updated__empty {
4474        local_var_req_builder = match "multi" {
4475            "multi" => local_var_req_builder.query(
4476                &local_var_str
4477                    .into_iter()
4478                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4480            ),
4481            _ => local_var_req_builder.query(&[(
4482                "last_updated__empty",
4483                &local_var_str
4484                    .into_iter()
4485                    .map(|p| p.to_string())
4486                    .collect::<Vec<String>>()
4487                    .join(",")
4488                    .to_string(),
4489            )]),
4490        };
4491    }
4492    if let Some(ref local_var_str) = last_updated__gt {
4493        local_var_req_builder = match "multi" {
4494            "multi" => local_var_req_builder.query(
4495                &local_var_str
4496                    .into_iter()
4497                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4499            ),
4500            _ => local_var_req_builder.query(&[(
4501                "last_updated__gt",
4502                &local_var_str
4503                    .into_iter()
4504                    .map(|p| p.to_string())
4505                    .collect::<Vec<String>>()
4506                    .join(",")
4507                    .to_string(),
4508            )]),
4509        };
4510    }
4511    if let Some(ref local_var_str) = last_updated__gte {
4512        local_var_req_builder = match "multi" {
4513            "multi" => local_var_req_builder.query(
4514                &local_var_str
4515                    .into_iter()
4516                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4518            ),
4519            _ => local_var_req_builder.query(&[(
4520                "last_updated__gte",
4521                &local_var_str
4522                    .into_iter()
4523                    .map(|p| p.to_string())
4524                    .collect::<Vec<String>>()
4525                    .join(",")
4526                    .to_string(),
4527            )]),
4528        };
4529    }
4530    if let Some(ref local_var_str) = last_updated__lt {
4531        local_var_req_builder = match "multi" {
4532            "multi" => local_var_req_builder.query(
4533                &local_var_str
4534                    .into_iter()
4535                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4537            ),
4538            _ => local_var_req_builder.query(&[(
4539                "last_updated__lt",
4540                &local_var_str
4541                    .into_iter()
4542                    .map(|p| p.to_string())
4543                    .collect::<Vec<String>>()
4544                    .join(",")
4545                    .to_string(),
4546            )]),
4547        };
4548    }
4549    if let Some(ref local_var_str) = last_updated__lte {
4550        local_var_req_builder = match "multi" {
4551            "multi" => local_var_req_builder.query(
4552                &local_var_str
4553                    .into_iter()
4554                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4556            ),
4557            _ => local_var_req_builder.query(&[(
4558                "last_updated__lte",
4559                &local_var_str
4560                    .into_iter()
4561                    .map(|p| p.to_string())
4562                    .collect::<Vec<String>>()
4563                    .join(",")
4564                    .to_string(),
4565            )]),
4566        };
4567    }
4568    if let Some(ref local_var_str) = last_updated__n {
4569        local_var_req_builder = match "multi" {
4570            "multi" => local_var_req_builder.query(
4571                &local_var_str
4572                    .into_iter()
4573                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4575            ),
4576            _ => local_var_req_builder.query(&[(
4577                "last_updated__n",
4578                &local_var_str
4579                    .into_iter()
4580                    .map(|p| p.to_string())
4581                    .collect::<Vec<String>>()
4582                    .join(",")
4583                    .to_string(),
4584            )]),
4585        };
4586    }
4587    if let Some(ref local_var_str) = limit {
4588        local_var_req_builder =
4589            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4590    }
4591    if let Some(ref local_var_str) = modified_by_request {
4592        local_var_req_builder =
4593            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
4594    }
4595    if let Some(ref local_var_str) = name {
4596        local_var_req_builder = match "multi" {
4597            "multi" => local_var_req_builder.query(
4598                &local_var_str
4599                    .into_iter()
4600                    .map(|p| ("name".to_owned(), p.to_string()))
4601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4602            ),
4603            _ => local_var_req_builder.query(&[(
4604                "name",
4605                &local_var_str
4606                    .into_iter()
4607                    .map(|p| p.to_string())
4608                    .collect::<Vec<String>>()
4609                    .join(",")
4610                    .to_string(),
4611            )]),
4612        };
4613    }
4614    if let Some(ref local_var_str) = name__empty {
4615        local_var_req_builder =
4616            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
4617    }
4618    if let Some(ref local_var_str) = name__ic {
4619        local_var_req_builder = match "multi" {
4620            "multi" => local_var_req_builder.query(
4621                &local_var_str
4622                    .into_iter()
4623                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4625            ),
4626            _ => local_var_req_builder.query(&[(
4627                "name__ic",
4628                &local_var_str
4629                    .into_iter()
4630                    .map(|p| p.to_string())
4631                    .collect::<Vec<String>>()
4632                    .join(",")
4633                    .to_string(),
4634            )]),
4635        };
4636    }
4637    if let Some(ref local_var_str) = name__ie {
4638        local_var_req_builder = match "multi" {
4639            "multi" => local_var_req_builder.query(
4640                &local_var_str
4641                    .into_iter()
4642                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4644            ),
4645            _ => local_var_req_builder.query(&[(
4646                "name__ie",
4647                &local_var_str
4648                    .into_iter()
4649                    .map(|p| p.to_string())
4650                    .collect::<Vec<String>>()
4651                    .join(",")
4652                    .to_string(),
4653            )]),
4654        };
4655    }
4656    if let Some(ref local_var_str) = name__iew {
4657        local_var_req_builder = match "multi" {
4658            "multi" => local_var_req_builder.query(
4659                &local_var_str
4660                    .into_iter()
4661                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4663            ),
4664            _ => local_var_req_builder.query(&[(
4665                "name__iew",
4666                &local_var_str
4667                    .into_iter()
4668                    .map(|p| p.to_string())
4669                    .collect::<Vec<String>>()
4670                    .join(",")
4671                    .to_string(),
4672            )]),
4673        };
4674    }
4675    if let Some(ref local_var_str) = name__iregex {
4676        local_var_req_builder = match "multi" {
4677            "multi" => local_var_req_builder.query(
4678                &local_var_str
4679                    .into_iter()
4680                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
4681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4682            ),
4683            _ => local_var_req_builder.query(&[(
4684                "name__iregex",
4685                &local_var_str
4686                    .into_iter()
4687                    .map(|p| p.to_string())
4688                    .collect::<Vec<String>>()
4689                    .join(",")
4690                    .to_string(),
4691            )]),
4692        };
4693    }
4694    if let Some(ref local_var_str) = name__isw {
4695        local_var_req_builder = match "multi" {
4696            "multi" => local_var_req_builder.query(
4697                &local_var_str
4698                    .into_iter()
4699                    .map(|p| ("name__isw".to_owned(), p.to_string()))
4700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4701            ),
4702            _ => local_var_req_builder.query(&[(
4703                "name__isw",
4704                &local_var_str
4705                    .into_iter()
4706                    .map(|p| p.to_string())
4707                    .collect::<Vec<String>>()
4708                    .join(",")
4709                    .to_string(),
4710            )]),
4711        };
4712    }
4713    if let Some(ref local_var_str) = name__n {
4714        local_var_req_builder = match "multi" {
4715            "multi" => local_var_req_builder.query(
4716                &local_var_str
4717                    .into_iter()
4718                    .map(|p| ("name__n".to_owned(), p.to_string()))
4719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4720            ),
4721            _ => local_var_req_builder.query(&[(
4722                "name__n",
4723                &local_var_str
4724                    .into_iter()
4725                    .map(|p| p.to_string())
4726                    .collect::<Vec<String>>()
4727                    .join(",")
4728                    .to_string(),
4729            )]),
4730        };
4731    }
4732    if let Some(ref local_var_str) = name__nic {
4733        local_var_req_builder = match "multi" {
4734            "multi" => local_var_req_builder.query(
4735                &local_var_str
4736                    .into_iter()
4737                    .map(|p| ("name__nic".to_owned(), p.to_string()))
4738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4739            ),
4740            _ => local_var_req_builder.query(&[(
4741                "name__nic",
4742                &local_var_str
4743                    .into_iter()
4744                    .map(|p| p.to_string())
4745                    .collect::<Vec<String>>()
4746                    .join(",")
4747                    .to_string(),
4748            )]),
4749        };
4750    }
4751    if let Some(ref local_var_str) = name__nie {
4752        local_var_req_builder = match "multi" {
4753            "multi" => local_var_req_builder.query(
4754                &local_var_str
4755                    .into_iter()
4756                    .map(|p| ("name__nie".to_owned(), p.to_string()))
4757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4758            ),
4759            _ => local_var_req_builder.query(&[(
4760                "name__nie",
4761                &local_var_str
4762                    .into_iter()
4763                    .map(|p| p.to_string())
4764                    .collect::<Vec<String>>()
4765                    .join(",")
4766                    .to_string(),
4767            )]),
4768        };
4769    }
4770    if let Some(ref local_var_str) = name__niew {
4771        local_var_req_builder = match "multi" {
4772            "multi" => local_var_req_builder.query(
4773                &local_var_str
4774                    .into_iter()
4775                    .map(|p| ("name__niew".to_owned(), p.to_string()))
4776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4777            ),
4778            _ => local_var_req_builder.query(&[(
4779                "name__niew",
4780                &local_var_str
4781                    .into_iter()
4782                    .map(|p| p.to_string())
4783                    .collect::<Vec<String>>()
4784                    .join(",")
4785                    .to_string(),
4786            )]),
4787        };
4788    }
4789    if let Some(ref local_var_str) = name__nisw {
4790        local_var_req_builder = match "multi" {
4791            "multi" => local_var_req_builder.query(
4792                &local_var_str
4793                    .into_iter()
4794                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
4795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4796            ),
4797            _ => local_var_req_builder.query(&[(
4798                "name__nisw",
4799                &local_var_str
4800                    .into_iter()
4801                    .map(|p| p.to_string())
4802                    .collect::<Vec<String>>()
4803                    .join(",")
4804                    .to_string(),
4805            )]),
4806        };
4807    }
4808    if let Some(ref local_var_str) = name__regex {
4809        local_var_req_builder = match "multi" {
4810            "multi" => local_var_req_builder.query(
4811                &local_var_str
4812                    .into_iter()
4813                    .map(|p| ("name__regex".to_owned(), p.to_string()))
4814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4815            ),
4816            _ => local_var_req_builder.query(&[(
4817                "name__regex",
4818                &local_var_str
4819                    .into_iter()
4820                    .map(|p| p.to_string())
4821                    .collect::<Vec<String>>()
4822                    .join(",")
4823                    .to_string(),
4824            )]),
4825        };
4826    }
4827    if let Some(ref local_var_str) = offset {
4828        local_var_req_builder =
4829            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4830    }
4831    if let Some(ref local_var_str) = ordering {
4832        local_var_req_builder =
4833            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
4834    }
4835    if let Some(ref local_var_str) = q {
4836        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
4837    }
4838    if let Some(ref local_var_str) = slug {
4839        local_var_req_builder = match "multi" {
4840            "multi" => local_var_req_builder.query(
4841                &local_var_str
4842                    .into_iter()
4843                    .map(|p| ("slug".to_owned(), p.to_string()))
4844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4845            ),
4846            _ => local_var_req_builder.query(&[(
4847                "slug",
4848                &local_var_str
4849                    .into_iter()
4850                    .map(|p| p.to_string())
4851                    .collect::<Vec<String>>()
4852                    .join(",")
4853                    .to_string(),
4854            )]),
4855        };
4856    }
4857    if let Some(ref local_var_str) = slug__empty {
4858        local_var_req_builder =
4859            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
4860    }
4861    if let Some(ref local_var_str) = slug__ic {
4862        local_var_req_builder = match "multi" {
4863            "multi" => local_var_req_builder.query(
4864                &local_var_str
4865                    .into_iter()
4866                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
4867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4868            ),
4869            _ => local_var_req_builder.query(&[(
4870                "slug__ic",
4871                &local_var_str
4872                    .into_iter()
4873                    .map(|p| p.to_string())
4874                    .collect::<Vec<String>>()
4875                    .join(",")
4876                    .to_string(),
4877            )]),
4878        };
4879    }
4880    if let Some(ref local_var_str) = slug__ie {
4881        local_var_req_builder = match "multi" {
4882            "multi" => local_var_req_builder.query(
4883                &local_var_str
4884                    .into_iter()
4885                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
4886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4887            ),
4888            _ => local_var_req_builder.query(&[(
4889                "slug__ie",
4890                &local_var_str
4891                    .into_iter()
4892                    .map(|p| p.to_string())
4893                    .collect::<Vec<String>>()
4894                    .join(",")
4895                    .to_string(),
4896            )]),
4897        };
4898    }
4899    if let Some(ref local_var_str) = slug__iew {
4900        local_var_req_builder = match "multi" {
4901            "multi" => local_var_req_builder.query(
4902                &local_var_str
4903                    .into_iter()
4904                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
4905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4906            ),
4907            _ => local_var_req_builder.query(&[(
4908                "slug__iew",
4909                &local_var_str
4910                    .into_iter()
4911                    .map(|p| p.to_string())
4912                    .collect::<Vec<String>>()
4913                    .join(",")
4914                    .to_string(),
4915            )]),
4916        };
4917    }
4918    if let Some(ref local_var_str) = slug__iregex {
4919        local_var_req_builder = match "multi" {
4920            "multi" => local_var_req_builder.query(
4921                &local_var_str
4922                    .into_iter()
4923                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
4924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4925            ),
4926            _ => local_var_req_builder.query(&[(
4927                "slug__iregex",
4928                &local_var_str
4929                    .into_iter()
4930                    .map(|p| p.to_string())
4931                    .collect::<Vec<String>>()
4932                    .join(",")
4933                    .to_string(),
4934            )]),
4935        };
4936    }
4937    if let Some(ref local_var_str) = slug__isw {
4938        local_var_req_builder = match "multi" {
4939            "multi" => local_var_req_builder.query(
4940                &local_var_str
4941                    .into_iter()
4942                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
4943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4944            ),
4945            _ => local_var_req_builder.query(&[(
4946                "slug__isw",
4947                &local_var_str
4948                    .into_iter()
4949                    .map(|p| p.to_string())
4950                    .collect::<Vec<String>>()
4951                    .join(",")
4952                    .to_string(),
4953            )]),
4954        };
4955    }
4956    if let Some(ref local_var_str) = slug__n {
4957        local_var_req_builder = match "multi" {
4958            "multi" => local_var_req_builder.query(
4959                &local_var_str
4960                    .into_iter()
4961                    .map(|p| ("slug__n".to_owned(), p.to_string()))
4962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4963            ),
4964            _ => local_var_req_builder.query(&[(
4965                "slug__n",
4966                &local_var_str
4967                    .into_iter()
4968                    .map(|p| p.to_string())
4969                    .collect::<Vec<String>>()
4970                    .join(",")
4971                    .to_string(),
4972            )]),
4973        };
4974    }
4975    if let Some(ref local_var_str) = slug__nic {
4976        local_var_req_builder = match "multi" {
4977            "multi" => local_var_req_builder.query(
4978                &local_var_str
4979                    .into_iter()
4980                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
4981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4982            ),
4983            _ => local_var_req_builder.query(&[(
4984                "slug__nic",
4985                &local_var_str
4986                    .into_iter()
4987                    .map(|p| p.to_string())
4988                    .collect::<Vec<String>>()
4989                    .join(",")
4990                    .to_string(),
4991            )]),
4992        };
4993    }
4994    if let Some(ref local_var_str) = slug__nie {
4995        local_var_req_builder = match "multi" {
4996            "multi" => local_var_req_builder.query(
4997                &local_var_str
4998                    .into_iter()
4999                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
5000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5001            ),
5002            _ => local_var_req_builder.query(&[(
5003                "slug__nie",
5004                &local_var_str
5005                    .into_iter()
5006                    .map(|p| p.to_string())
5007                    .collect::<Vec<String>>()
5008                    .join(",")
5009                    .to_string(),
5010            )]),
5011        };
5012    }
5013    if let Some(ref local_var_str) = slug__niew {
5014        local_var_req_builder = match "multi" {
5015            "multi" => local_var_req_builder.query(
5016                &local_var_str
5017                    .into_iter()
5018                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
5019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5020            ),
5021            _ => local_var_req_builder.query(&[(
5022                "slug__niew",
5023                &local_var_str
5024                    .into_iter()
5025                    .map(|p| p.to_string())
5026                    .collect::<Vec<String>>()
5027                    .join(",")
5028                    .to_string(),
5029            )]),
5030        };
5031    }
5032    if let Some(ref local_var_str) = slug__nisw {
5033        local_var_req_builder = match "multi" {
5034            "multi" => local_var_req_builder.query(
5035                &local_var_str
5036                    .into_iter()
5037                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
5038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5039            ),
5040            _ => local_var_req_builder.query(&[(
5041                "slug__nisw",
5042                &local_var_str
5043                    .into_iter()
5044                    .map(|p| p.to_string())
5045                    .collect::<Vec<String>>()
5046                    .join(",")
5047                    .to_string(),
5048            )]),
5049        };
5050    }
5051    if let Some(ref local_var_str) = slug__regex {
5052        local_var_req_builder = match "multi" {
5053            "multi" => local_var_req_builder.query(
5054                &local_var_str
5055                    .into_iter()
5056                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
5057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5058            ),
5059            _ => local_var_req_builder.query(&[(
5060                "slug__regex",
5061                &local_var_str
5062                    .into_iter()
5063                    .map(|p| p.to_string())
5064                    .collect::<Vec<String>>()
5065                    .join(",")
5066                    .to_string(),
5067            )]),
5068        };
5069    }
5070    if let Some(ref local_var_str) = tag {
5071        local_var_req_builder = match "multi" {
5072            "multi" => local_var_req_builder.query(
5073                &local_var_str
5074                    .into_iter()
5075                    .map(|p| ("tag".to_owned(), p.to_string()))
5076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5077            ),
5078            _ => local_var_req_builder.query(&[(
5079                "tag",
5080                &local_var_str
5081                    .into_iter()
5082                    .map(|p| p.to_string())
5083                    .collect::<Vec<String>>()
5084                    .join(",")
5085                    .to_string(),
5086            )]),
5087        };
5088    }
5089    if let Some(ref local_var_str) = tag__n {
5090        local_var_req_builder = match "multi" {
5091            "multi" => local_var_req_builder.query(
5092                &local_var_str
5093                    .into_iter()
5094                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5096            ),
5097            _ => local_var_req_builder.query(&[(
5098                "tag__n",
5099                &local_var_str
5100                    .into_iter()
5101                    .map(|p| p.to_string())
5102                    .collect::<Vec<String>>()
5103                    .join(",")
5104                    .to_string(),
5105            )]),
5106        };
5107    }
5108    if let Some(ref local_var_str) = tag_id {
5109        local_var_req_builder = match "multi" {
5110            "multi" => local_var_req_builder.query(
5111                &local_var_str
5112                    .into_iter()
5113                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5115            ),
5116            _ => local_var_req_builder.query(&[(
5117                "tag_id",
5118                &local_var_str
5119                    .into_iter()
5120                    .map(|p| p.to_string())
5121                    .collect::<Vec<String>>()
5122                    .join(",")
5123                    .to_string(),
5124            )]),
5125        };
5126    }
5127    if let Some(ref local_var_str) = tag_id__n {
5128        local_var_req_builder = match "multi" {
5129            "multi" => local_var_req_builder.query(
5130                &local_var_str
5131                    .into_iter()
5132                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5134            ),
5135            _ => local_var_req_builder.query(&[(
5136                "tag_id__n",
5137                &local_var_str
5138                    .into_iter()
5139                    .map(|p| p.to_string())
5140                    .collect::<Vec<String>>()
5141                    .join(",")
5142                    .to_string(),
5143            )]),
5144        };
5145    }
5146    if let Some(ref local_var_str) = updated_by_request {
5147        local_var_req_builder =
5148            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5149    }
5150    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5151        local_var_req_builder =
5152            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5153    }
5154    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5155        let local_var_key = local_var_apikey.key.clone();
5156        let local_var_value = match local_var_apikey.prefix {
5157            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5158            None => local_var_key,
5159        };
5160        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5161    };
5162
5163    let local_var_req = local_var_req_builder.build()?;
5164    let local_var_resp = local_var_client.execute(local_var_req).await?;
5165
5166    let local_var_status = local_var_resp.status();
5167    let local_var_content = local_var_resp.text().await?;
5168
5169    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5170        serde_json::from_str(&local_var_content).map_err(Error::from)
5171    } else {
5172        let local_var_entity: Option<TenancyContactRolesListError> =
5173            serde_json::from_str(&local_var_content).ok();
5174        let local_var_error = ResponseContent {
5175            status: local_var_status,
5176            content: local_var_content,
5177            entity: local_var_entity,
5178        };
5179        Err(Error::ResponseError(local_var_error))
5180    }
5181}
5182
5183/// Patch a contact role object.
5184pub async fn tenancy_contact_roles_partial_update(
5185    configuration: &configuration::Configuration,
5186    id: i32,
5187    patched_contact_role_request: Option<crate::models::PatchedContactRoleRequest>,
5188) -> Result<crate::models::ContactRole, Error<TenancyContactRolesPartialUpdateError>> {
5189    let local_var_configuration = configuration;
5190
5191    let local_var_client = &local_var_configuration.client;
5192
5193    let local_var_uri_str = format!(
5194        "{}/api/tenancy/contact-roles/{id}/",
5195        local_var_configuration.base_path,
5196        id = id
5197    );
5198    let mut local_var_req_builder =
5199        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5200
5201    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5202        local_var_req_builder =
5203            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5204    }
5205    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5206        let local_var_key = local_var_apikey.key.clone();
5207        let local_var_value = match local_var_apikey.prefix {
5208            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5209            None => local_var_key,
5210        };
5211        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5212    };
5213    local_var_req_builder = local_var_req_builder.json(&patched_contact_role_request);
5214
5215    let local_var_req = local_var_req_builder.build()?;
5216    let local_var_resp = local_var_client.execute(local_var_req).await?;
5217
5218    let local_var_status = local_var_resp.status();
5219    let local_var_content = local_var_resp.text().await?;
5220
5221    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5222        serde_json::from_str(&local_var_content).map_err(Error::from)
5223    } else {
5224        let local_var_entity: Option<TenancyContactRolesPartialUpdateError> =
5225            serde_json::from_str(&local_var_content).ok();
5226        let local_var_error = ResponseContent {
5227            status: local_var_status,
5228            content: local_var_content,
5229            entity: local_var_entity,
5230        };
5231        Err(Error::ResponseError(local_var_error))
5232    }
5233}
5234
5235/// Get a contact role object.
5236pub async fn tenancy_contact_roles_retrieve(
5237    configuration: &configuration::Configuration,
5238    id: i32,
5239) -> Result<crate::models::ContactRole, Error<TenancyContactRolesRetrieveError>> {
5240    let local_var_configuration = configuration;
5241
5242    let local_var_client = &local_var_configuration.client;
5243
5244    let local_var_uri_str = format!(
5245        "{}/api/tenancy/contact-roles/{id}/",
5246        local_var_configuration.base_path,
5247        id = id
5248    );
5249    let mut local_var_req_builder =
5250        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5251
5252    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5253        local_var_req_builder =
5254            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5255    }
5256    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5257        let local_var_key = local_var_apikey.key.clone();
5258        let local_var_value = match local_var_apikey.prefix {
5259            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5260            None => local_var_key,
5261        };
5262        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5263    };
5264
5265    let local_var_req = local_var_req_builder.build()?;
5266    let local_var_resp = local_var_client.execute(local_var_req).await?;
5267
5268    let local_var_status = local_var_resp.status();
5269    let local_var_content = local_var_resp.text().await?;
5270
5271    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5272        serde_json::from_str(&local_var_content).map_err(Error::from)
5273    } else {
5274        let local_var_entity: Option<TenancyContactRolesRetrieveError> =
5275            serde_json::from_str(&local_var_content).ok();
5276        let local_var_error = ResponseContent {
5277            status: local_var_status,
5278            content: local_var_content,
5279            entity: local_var_entity,
5280        };
5281        Err(Error::ResponseError(local_var_error))
5282    }
5283}
5284
5285/// Put a contact role object.
5286pub async fn tenancy_contact_roles_update(
5287    configuration: &configuration::Configuration,
5288    id: i32,
5289    contact_role_request: crate::models::ContactRoleRequest,
5290) -> Result<crate::models::ContactRole, Error<TenancyContactRolesUpdateError>> {
5291    let local_var_configuration = configuration;
5292
5293    let local_var_client = &local_var_configuration.client;
5294
5295    let local_var_uri_str = format!(
5296        "{}/api/tenancy/contact-roles/{id}/",
5297        local_var_configuration.base_path,
5298        id = id
5299    );
5300    let mut local_var_req_builder =
5301        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5302
5303    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5304        local_var_req_builder =
5305            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5306    }
5307    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5308        let local_var_key = local_var_apikey.key.clone();
5309        let local_var_value = match local_var_apikey.prefix {
5310            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5311            None => local_var_key,
5312        };
5313        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5314    };
5315    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
5316
5317    let local_var_req = local_var_req_builder.build()?;
5318    let local_var_resp = local_var_client.execute(local_var_req).await?;
5319
5320    let local_var_status = local_var_resp.status();
5321    let local_var_content = local_var_resp.text().await?;
5322
5323    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5324        serde_json::from_str(&local_var_content).map_err(Error::from)
5325    } else {
5326        let local_var_entity: Option<TenancyContactRolesUpdateError> =
5327            serde_json::from_str(&local_var_content).ok();
5328        let local_var_error = ResponseContent {
5329            status: local_var_status,
5330            content: local_var_content,
5331            entity: local_var_entity,
5332        };
5333        Err(Error::ResponseError(local_var_error))
5334    }
5335}
5336
5337/// Delete a list of contact objects.
5338pub async fn tenancy_contacts_bulk_destroy(
5339    configuration: &configuration::Configuration,
5340    contact_request: Vec<crate::models::ContactRequest>,
5341) -> Result<(), Error<TenancyContactsBulkDestroyError>> {
5342    let local_var_configuration = configuration;
5343
5344    let local_var_client = &local_var_configuration.client;
5345
5346    let local_var_uri_str = format!(
5347        "{}/api/tenancy/contacts/",
5348        local_var_configuration.base_path
5349    );
5350    let mut local_var_req_builder =
5351        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5352
5353    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5354        local_var_req_builder =
5355            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5356    }
5357    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5358        let local_var_key = local_var_apikey.key.clone();
5359        let local_var_value = match local_var_apikey.prefix {
5360            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5361            None => local_var_key,
5362        };
5363        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5364    };
5365    local_var_req_builder = local_var_req_builder.json(&contact_request);
5366
5367    let local_var_req = local_var_req_builder.build()?;
5368    let local_var_resp = local_var_client.execute(local_var_req).await?;
5369
5370    let local_var_status = local_var_resp.status();
5371    let local_var_content = local_var_resp.text().await?;
5372
5373    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5374        Ok(())
5375    } else {
5376        let local_var_entity: Option<TenancyContactsBulkDestroyError> =
5377            serde_json::from_str(&local_var_content).ok();
5378        let local_var_error = ResponseContent {
5379            status: local_var_status,
5380            content: local_var_content,
5381            entity: local_var_entity,
5382        };
5383        Err(Error::ResponseError(local_var_error))
5384    }
5385}
5386
5387/// Patch a list of contact objects.
5388pub async fn tenancy_contacts_bulk_partial_update(
5389    configuration: &configuration::Configuration,
5390    contact_request: Vec<crate::models::ContactRequest>,
5391) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkPartialUpdateError>> {
5392    let local_var_configuration = configuration;
5393
5394    let local_var_client = &local_var_configuration.client;
5395
5396    let local_var_uri_str = format!(
5397        "{}/api/tenancy/contacts/",
5398        local_var_configuration.base_path
5399    );
5400    let mut local_var_req_builder =
5401        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5402
5403    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5404        local_var_req_builder =
5405            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5406    }
5407    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5408        let local_var_key = local_var_apikey.key.clone();
5409        let local_var_value = match local_var_apikey.prefix {
5410            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5411            None => local_var_key,
5412        };
5413        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5414    };
5415    local_var_req_builder = local_var_req_builder.json(&contact_request);
5416
5417    let local_var_req = local_var_req_builder.build()?;
5418    let local_var_resp = local_var_client.execute(local_var_req).await?;
5419
5420    let local_var_status = local_var_resp.status();
5421    let local_var_content = local_var_resp.text().await?;
5422
5423    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5424        serde_json::from_str(&local_var_content).map_err(Error::from)
5425    } else {
5426        let local_var_entity: Option<TenancyContactsBulkPartialUpdateError> =
5427            serde_json::from_str(&local_var_content).ok();
5428        let local_var_error = ResponseContent {
5429            status: local_var_status,
5430            content: local_var_content,
5431            entity: local_var_entity,
5432        };
5433        Err(Error::ResponseError(local_var_error))
5434    }
5435}
5436
5437/// Put a list of contact objects.
5438pub async fn tenancy_contacts_bulk_update(
5439    configuration: &configuration::Configuration,
5440    contact_request: Vec<crate::models::ContactRequest>,
5441) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkUpdateError>> {
5442    let local_var_configuration = configuration;
5443
5444    let local_var_client = &local_var_configuration.client;
5445
5446    let local_var_uri_str = format!(
5447        "{}/api/tenancy/contacts/",
5448        local_var_configuration.base_path
5449    );
5450    let mut local_var_req_builder =
5451        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5452
5453    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5454        local_var_req_builder =
5455            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5456    }
5457    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5458        let local_var_key = local_var_apikey.key.clone();
5459        let local_var_value = match local_var_apikey.prefix {
5460            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5461            None => local_var_key,
5462        };
5463        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5464    };
5465    local_var_req_builder = local_var_req_builder.json(&contact_request);
5466
5467    let local_var_req = local_var_req_builder.build()?;
5468    let local_var_resp = local_var_client.execute(local_var_req).await?;
5469
5470    let local_var_status = local_var_resp.status();
5471    let local_var_content = local_var_resp.text().await?;
5472
5473    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5474        serde_json::from_str(&local_var_content).map_err(Error::from)
5475    } else {
5476        let local_var_entity: Option<TenancyContactsBulkUpdateError> =
5477            serde_json::from_str(&local_var_content).ok();
5478        let local_var_error = ResponseContent {
5479            status: local_var_status,
5480            content: local_var_content,
5481            entity: local_var_entity,
5482        };
5483        Err(Error::ResponseError(local_var_error))
5484    }
5485}
5486
5487/// Post a list of contact objects.
5488pub async fn tenancy_contacts_create(
5489    configuration: &configuration::Configuration,
5490    contact_request: crate::models::ContactRequest,
5491) -> Result<crate::models::Contact, Error<TenancyContactsCreateError>> {
5492    let local_var_configuration = configuration;
5493
5494    let local_var_client = &local_var_configuration.client;
5495
5496    let local_var_uri_str = format!(
5497        "{}/api/tenancy/contacts/",
5498        local_var_configuration.base_path
5499    );
5500    let mut local_var_req_builder =
5501        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5502
5503    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5504        local_var_req_builder =
5505            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5506    }
5507    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5508        let local_var_key = local_var_apikey.key.clone();
5509        let local_var_value = match local_var_apikey.prefix {
5510            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5511            None => local_var_key,
5512        };
5513        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5514    };
5515    local_var_req_builder = local_var_req_builder.json(&contact_request);
5516
5517    let local_var_req = local_var_req_builder.build()?;
5518    let local_var_resp = local_var_client.execute(local_var_req).await?;
5519
5520    let local_var_status = local_var_resp.status();
5521    let local_var_content = local_var_resp.text().await?;
5522
5523    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5524        serde_json::from_str(&local_var_content).map_err(Error::from)
5525    } else {
5526        let local_var_entity: Option<TenancyContactsCreateError> =
5527            serde_json::from_str(&local_var_content).ok();
5528        let local_var_error = ResponseContent {
5529            status: local_var_status,
5530            content: local_var_content,
5531            entity: local_var_entity,
5532        };
5533        Err(Error::ResponseError(local_var_error))
5534    }
5535}
5536
5537/// Delete a contact object.
5538pub async fn tenancy_contacts_destroy(
5539    configuration: &configuration::Configuration,
5540    id: i32,
5541) -> Result<(), Error<TenancyContactsDestroyError>> {
5542    let local_var_configuration = configuration;
5543
5544    let local_var_client = &local_var_configuration.client;
5545
5546    let local_var_uri_str = format!(
5547        "{}/api/tenancy/contacts/{id}/",
5548        local_var_configuration.base_path,
5549        id = id
5550    );
5551    let mut local_var_req_builder =
5552        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5553
5554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5555        local_var_req_builder =
5556            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5557    }
5558    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5559        let local_var_key = local_var_apikey.key.clone();
5560        let local_var_value = match local_var_apikey.prefix {
5561            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5562            None => local_var_key,
5563        };
5564        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5565    };
5566
5567    let local_var_req = local_var_req_builder.build()?;
5568    let local_var_resp = local_var_client.execute(local_var_req).await?;
5569
5570    let local_var_status = local_var_resp.status();
5571    let local_var_content = local_var_resp.text().await?;
5572
5573    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5574        Ok(())
5575    } else {
5576        let local_var_entity: Option<TenancyContactsDestroyError> =
5577            serde_json::from_str(&local_var_content).ok();
5578        let local_var_error = ResponseContent {
5579            status: local_var_status,
5580            content: local_var_content,
5581            entity: local_var_entity,
5582        };
5583        Err(Error::ResponseError(local_var_error))
5584    }
5585}
5586
5587/// Get a list of contact objects.
5588pub async fn tenancy_contacts_list(
5589    configuration: &configuration::Configuration,
5590    address: Option<Vec<String>>,
5591    address__empty: Option<bool>,
5592    address__ic: Option<Vec<String>>,
5593    address__ie: Option<Vec<String>>,
5594    address__iew: Option<Vec<String>>,
5595    address__iregex: Option<Vec<String>>,
5596    address__isw: Option<Vec<String>>,
5597    address__n: Option<Vec<String>>,
5598    address__nic: Option<Vec<String>>,
5599    address__nie: Option<Vec<String>>,
5600    address__niew: Option<Vec<String>>,
5601    address__nisw: Option<Vec<String>>,
5602    address__regex: Option<Vec<String>>,
5603    created: Option<Vec<String>>,
5604    created__empty: Option<Vec<String>>,
5605    created__gt: Option<Vec<String>>,
5606    created__gte: Option<Vec<String>>,
5607    created__lt: Option<Vec<String>>,
5608    created__lte: Option<Vec<String>>,
5609    created__n: Option<Vec<String>>,
5610    created_by_request: Option<&str>,
5611    description: Option<Vec<String>>,
5612    description__empty: Option<bool>,
5613    description__ic: Option<Vec<String>>,
5614    description__ie: Option<Vec<String>>,
5615    description__iew: Option<Vec<String>>,
5616    description__iregex: Option<Vec<String>>,
5617    description__isw: Option<Vec<String>>,
5618    description__n: Option<Vec<String>>,
5619    description__nic: Option<Vec<String>>,
5620    description__nie: Option<Vec<String>>,
5621    description__niew: Option<Vec<String>>,
5622    description__nisw: Option<Vec<String>>,
5623    description__regex: Option<Vec<String>>,
5624    email: Option<Vec<String>>,
5625    email__empty: Option<bool>,
5626    email__ic: Option<Vec<String>>,
5627    email__ie: Option<Vec<String>>,
5628    email__iew: Option<Vec<String>>,
5629    email__iregex: Option<Vec<String>>,
5630    email__isw: Option<Vec<String>>,
5631    email__n: Option<Vec<String>>,
5632    email__nic: Option<Vec<String>>,
5633    email__nie: Option<Vec<String>>,
5634    email__niew: Option<Vec<String>>,
5635    email__nisw: Option<Vec<String>>,
5636    email__regex: Option<Vec<String>>,
5637    group: Option<Vec<String>>,
5638    group__n: Option<Vec<String>>,
5639    group_id: Option<Vec<String>>,
5640    group_id__n: Option<Vec<String>>,
5641    id: Option<Vec<i32>>,
5642    id__empty: Option<bool>,
5643    id__gt: Option<Vec<i32>>,
5644    id__gte: Option<Vec<i32>>,
5645    id__lt: Option<Vec<i32>>,
5646    id__lte: Option<Vec<i32>>,
5647    id__n: Option<Vec<i32>>,
5648    last_updated: Option<Vec<String>>,
5649    last_updated__empty: Option<Vec<String>>,
5650    last_updated__gt: Option<Vec<String>>,
5651    last_updated__gte: Option<Vec<String>>,
5652    last_updated__lt: Option<Vec<String>>,
5653    last_updated__lte: Option<Vec<String>>,
5654    last_updated__n: Option<Vec<String>>,
5655    limit: Option<i32>,
5656    link: Option<Vec<String>>,
5657    link__empty: Option<bool>,
5658    link__ic: Option<Vec<String>>,
5659    link__ie: Option<Vec<String>>,
5660    link__iew: Option<Vec<String>>,
5661    link__iregex: Option<Vec<String>>,
5662    link__isw: Option<Vec<String>>,
5663    link__n: Option<Vec<String>>,
5664    link__nic: Option<Vec<String>>,
5665    link__nie: Option<Vec<String>>,
5666    link__niew: Option<Vec<String>>,
5667    link__nisw: Option<Vec<String>>,
5668    link__regex: Option<Vec<String>>,
5669    modified_by_request: Option<&str>,
5670    name: Option<Vec<String>>,
5671    name__empty: Option<bool>,
5672    name__ic: Option<Vec<String>>,
5673    name__ie: Option<Vec<String>>,
5674    name__iew: Option<Vec<String>>,
5675    name__iregex: Option<Vec<String>>,
5676    name__isw: Option<Vec<String>>,
5677    name__n: Option<Vec<String>>,
5678    name__nic: Option<Vec<String>>,
5679    name__nie: Option<Vec<String>>,
5680    name__niew: Option<Vec<String>>,
5681    name__nisw: Option<Vec<String>>,
5682    name__regex: Option<Vec<String>>,
5683    offset: Option<i32>,
5684    ordering: Option<&str>,
5685    phone: Option<Vec<String>>,
5686    phone__empty: Option<bool>,
5687    phone__ic: Option<Vec<String>>,
5688    phone__ie: Option<Vec<String>>,
5689    phone__iew: Option<Vec<String>>,
5690    phone__iregex: Option<Vec<String>>,
5691    phone__isw: Option<Vec<String>>,
5692    phone__n: Option<Vec<String>>,
5693    phone__nic: Option<Vec<String>>,
5694    phone__nie: Option<Vec<String>>,
5695    phone__niew: Option<Vec<String>>,
5696    phone__nisw: Option<Vec<String>>,
5697    phone__regex: Option<Vec<String>>,
5698    q: Option<&str>,
5699    tag: Option<Vec<String>>,
5700    tag__n: Option<Vec<String>>,
5701    tag_id: Option<Vec<i32>>,
5702    tag_id__n: Option<Vec<i32>>,
5703    title: Option<Vec<String>>,
5704    title__empty: Option<bool>,
5705    title__ic: Option<Vec<String>>,
5706    title__ie: Option<Vec<String>>,
5707    title__iew: Option<Vec<String>>,
5708    title__iregex: Option<Vec<String>>,
5709    title__isw: Option<Vec<String>>,
5710    title__n: Option<Vec<String>>,
5711    title__nic: Option<Vec<String>>,
5712    title__nie: Option<Vec<String>>,
5713    title__niew: Option<Vec<String>>,
5714    title__nisw: Option<Vec<String>>,
5715    title__regex: Option<Vec<String>>,
5716    updated_by_request: Option<&str>,
5717) -> Result<crate::models::PaginatedContactList, Error<TenancyContactsListError>> {
5718    let local_var_configuration = configuration;
5719
5720    let local_var_client = &local_var_configuration.client;
5721
5722    let local_var_uri_str = format!(
5723        "{}/api/tenancy/contacts/",
5724        local_var_configuration.base_path
5725    );
5726    let mut local_var_req_builder =
5727        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5728
5729    if let Some(ref local_var_str) = address {
5730        local_var_req_builder = match "multi" {
5731            "multi" => local_var_req_builder.query(
5732                &local_var_str
5733                    .into_iter()
5734                    .map(|p| ("address".to_owned(), p.to_string()))
5735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5736            ),
5737            _ => local_var_req_builder.query(&[(
5738                "address",
5739                &local_var_str
5740                    .into_iter()
5741                    .map(|p| p.to_string())
5742                    .collect::<Vec<String>>()
5743                    .join(",")
5744                    .to_string(),
5745            )]),
5746        };
5747    }
5748    if let Some(ref local_var_str) = address__empty {
5749        local_var_req_builder =
5750            local_var_req_builder.query(&[("address__empty", &local_var_str.to_string())]);
5751    }
5752    if let Some(ref local_var_str) = address__ic {
5753        local_var_req_builder = match "multi" {
5754            "multi" => local_var_req_builder.query(
5755                &local_var_str
5756                    .into_iter()
5757                    .map(|p| ("address__ic".to_owned(), p.to_string()))
5758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5759            ),
5760            _ => local_var_req_builder.query(&[(
5761                "address__ic",
5762                &local_var_str
5763                    .into_iter()
5764                    .map(|p| p.to_string())
5765                    .collect::<Vec<String>>()
5766                    .join(",")
5767                    .to_string(),
5768            )]),
5769        };
5770    }
5771    if let Some(ref local_var_str) = address__ie {
5772        local_var_req_builder = match "multi" {
5773            "multi" => local_var_req_builder.query(
5774                &local_var_str
5775                    .into_iter()
5776                    .map(|p| ("address__ie".to_owned(), p.to_string()))
5777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5778            ),
5779            _ => local_var_req_builder.query(&[(
5780                "address__ie",
5781                &local_var_str
5782                    .into_iter()
5783                    .map(|p| p.to_string())
5784                    .collect::<Vec<String>>()
5785                    .join(",")
5786                    .to_string(),
5787            )]),
5788        };
5789    }
5790    if let Some(ref local_var_str) = address__iew {
5791        local_var_req_builder = match "multi" {
5792            "multi" => local_var_req_builder.query(
5793                &local_var_str
5794                    .into_iter()
5795                    .map(|p| ("address__iew".to_owned(), p.to_string()))
5796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5797            ),
5798            _ => local_var_req_builder.query(&[(
5799                "address__iew",
5800                &local_var_str
5801                    .into_iter()
5802                    .map(|p| p.to_string())
5803                    .collect::<Vec<String>>()
5804                    .join(",")
5805                    .to_string(),
5806            )]),
5807        };
5808    }
5809    if let Some(ref local_var_str) = address__iregex {
5810        local_var_req_builder = match "multi" {
5811            "multi" => local_var_req_builder.query(
5812                &local_var_str
5813                    .into_iter()
5814                    .map(|p| ("address__iregex".to_owned(), p.to_string()))
5815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5816            ),
5817            _ => local_var_req_builder.query(&[(
5818                "address__iregex",
5819                &local_var_str
5820                    .into_iter()
5821                    .map(|p| p.to_string())
5822                    .collect::<Vec<String>>()
5823                    .join(",")
5824                    .to_string(),
5825            )]),
5826        };
5827    }
5828    if let Some(ref local_var_str) = address__isw {
5829        local_var_req_builder = match "multi" {
5830            "multi" => local_var_req_builder.query(
5831                &local_var_str
5832                    .into_iter()
5833                    .map(|p| ("address__isw".to_owned(), p.to_string()))
5834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5835            ),
5836            _ => local_var_req_builder.query(&[(
5837                "address__isw",
5838                &local_var_str
5839                    .into_iter()
5840                    .map(|p| p.to_string())
5841                    .collect::<Vec<String>>()
5842                    .join(",")
5843                    .to_string(),
5844            )]),
5845        };
5846    }
5847    if let Some(ref local_var_str) = address__n {
5848        local_var_req_builder = match "multi" {
5849            "multi" => local_var_req_builder.query(
5850                &local_var_str
5851                    .into_iter()
5852                    .map(|p| ("address__n".to_owned(), p.to_string()))
5853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5854            ),
5855            _ => local_var_req_builder.query(&[(
5856                "address__n",
5857                &local_var_str
5858                    .into_iter()
5859                    .map(|p| p.to_string())
5860                    .collect::<Vec<String>>()
5861                    .join(",")
5862                    .to_string(),
5863            )]),
5864        };
5865    }
5866    if let Some(ref local_var_str) = address__nic {
5867        local_var_req_builder = match "multi" {
5868            "multi" => local_var_req_builder.query(
5869                &local_var_str
5870                    .into_iter()
5871                    .map(|p| ("address__nic".to_owned(), p.to_string()))
5872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5873            ),
5874            _ => local_var_req_builder.query(&[(
5875                "address__nic",
5876                &local_var_str
5877                    .into_iter()
5878                    .map(|p| p.to_string())
5879                    .collect::<Vec<String>>()
5880                    .join(",")
5881                    .to_string(),
5882            )]),
5883        };
5884    }
5885    if let Some(ref local_var_str) = address__nie {
5886        local_var_req_builder = match "multi" {
5887            "multi" => local_var_req_builder.query(
5888                &local_var_str
5889                    .into_iter()
5890                    .map(|p| ("address__nie".to_owned(), p.to_string()))
5891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5892            ),
5893            _ => local_var_req_builder.query(&[(
5894                "address__nie",
5895                &local_var_str
5896                    .into_iter()
5897                    .map(|p| p.to_string())
5898                    .collect::<Vec<String>>()
5899                    .join(",")
5900                    .to_string(),
5901            )]),
5902        };
5903    }
5904    if let Some(ref local_var_str) = address__niew {
5905        local_var_req_builder = match "multi" {
5906            "multi" => local_var_req_builder.query(
5907                &local_var_str
5908                    .into_iter()
5909                    .map(|p| ("address__niew".to_owned(), p.to_string()))
5910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5911            ),
5912            _ => local_var_req_builder.query(&[(
5913                "address__niew",
5914                &local_var_str
5915                    .into_iter()
5916                    .map(|p| p.to_string())
5917                    .collect::<Vec<String>>()
5918                    .join(",")
5919                    .to_string(),
5920            )]),
5921        };
5922    }
5923    if let Some(ref local_var_str) = address__nisw {
5924        local_var_req_builder = match "multi" {
5925            "multi" => local_var_req_builder.query(
5926                &local_var_str
5927                    .into_iter()
5928                    .map(|p| ("address__nisw".to_owned(), p.to_string()))
5929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5930            ),
5931            _ => local_var_req_builder.query(&[(
5932                "address__nisw",
5933                &local_var_str
5934                    .into_iter()
5935                    .map(|p| p.to_string())
5936                    .collect::<Vec<String>>()
5937                    .join(",")
5938                    .to_string(),
5939            )]),
5940        };
5941    }
5942    if let Some(ref local_var_str) = address__regex {
5943        local_var_req_builder = match "multi" {
5944            "multi" => local_var_req_builder.query(
5945                &local_var_str
5946                    .into_iter()
5947                    .map(|p| ("address__regex".to_owned(), p.to_string()))
5948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5949            ),
5950            _ => local_var_req_builder.query(&[(
5951                "address__regex",
5952                &local_var_str
5953                    .into_iter()
5954                    .map(|p| p.to_string())
5955                    .collect::<Vec<String>>()
5956                    .join(",")
5957                    .to_string(),
5958            )]),
5959        };
5960    }
5961    if let Some(ref local_var_str) = created {
5962        local_var_req_builder = match "multi" {
5963            "multi" => local_var_req_builder.query(
5964                &local_var_str
5965                    .into_iter()
5966                    .map(|p| ("created".to_owned(), p.to_string()))
5967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5968            ),
5969            _ => local_var_req_builder.query(&[(
5970                "created",
5971                &local_var_str
5972                    .into_iter()
5973                    .map(|p| p.to_string())
5974                    .collect::<Vec<String>>()
5975                    .join(",")
5976                    .to_string(),
5977            )]),
5978        };
5979    }
5980    if let Some(ref local_var_str) = created__empty {
5981        local_var_req_builder = match "multi" {
5982            "multi" => local_var_req_builder.query(
5983                &local_var_str
5984                    .into_iter()
5985                    .map(|p| ("created__empty".to_owned(), p.to_string()))
5986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5987            ),
5988            _ => local_var_req_builder.query(&[(
5989                "created__empty",
5990                &local_var_str
5991                    .into_iter()
5992                    .map(|p| p.to_string())
5993                    .collect::<Vec<String>>()
5994                    .join(",")
5995                    .to_string(),
5996            )]),
5997        };
5998    }
5999    if let Some(ref local_var_str) = created__gt {
6000        local_var_req_builder = match "multi" {
6001            "multi" => local_var_req_builder.query(
6002                &local_var_str
6003                    .into_iter()
6004                    .map(|p| ("created__gt".to_owned(), p.to_string()))
6005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6006            ),
6007            _ => local_var_req_builder.query(&[(
6008                "created__gt",
6009                &local_var_str
6010                    .into_iter()
6011                    .map(|p| p.to_string())
6012                    .collect::<Vec<String>>()
6013                    .join(",")
6014                    .to_string(),
6015            )]),
6016        };
6017    }
6018    if let Some(ref local_var_str) = created__gte {
6019        local_var_req_builder = match "multi" {
6020            "multi" => local_var_req_builder.query(
6021                &local_var_str
6022                    .into_iter()
6023                    .map(|p| ("created__gte".to_owned(), p.to_string()))
6024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6025            ),
6026            _ => local_var_req_builder.query(&[(
6027                "created__gte",
6028                &local_var_str
6029                    .into_iter()
6030                    .map(|p| p.to_string())
6031                    .collect::<Vec<String>>()
6032                    .join(",")
6033                    .to_string(),
6034            )]),
6035        };
6036    }
6037    if let Some(ref local_var_str) = created__lt {
6038        local_var_req_builder = match "multi" {
6039            "multi" => local_var_req_builder.query(
6040                &local_var_str
6041                    .into_iter()
6042                    .map(|p| ("created__lt".to_owned(), p.to_string()))
6043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6044            ),
6045            _ => local_var_req_builder.query(&[(
6046                "created__lt",
6047                &local_var_str
6048                    .into_iter()
6049                    .map(|p| p.to_string())
6050                    .collect::<Vec<String>>()
6051                    .join(",")
6052                    .to_string(),
6053            )]),
6054        };
6055    }
6056    if let Some(ref local_var_str) = created__lte {
6057        local_var_req_builder = match "multi" {
6058            "multi" => local_var_req_builder.query(
6059                &local_var_str
6060                    .into_iter()
6061                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6063            ),
6064            _ => local_var_req_builder.query(&[(
6065                "created__lte",
6066                &local_var_str
6067                    .into_iter()
6068                    .map(|p| p.to_string())
6069                    .collect::<Vec<String>>()
6070                    .join(",")
6071                    .to_string(),
6072            )]),
6073        };
6074    }
6075    if let Some(ref local_var_str) = created__n {
6076        local_var_req_builder = match "multi" {
6077            "multi" => local_var_req_builder.query(
6078                &local_var_str
6079                    .into_iter()
6080                    .map(|p| ("created__n".to_owned(), p.to_string()))
6081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6082            ),
6083            _ => local_var_req_builder.query(&[(
6084                "created__n",
6085                &local_var_str
6086                    .into_iter()
6087                    .map(|p| p.to_string())
6088                    .collect::<Vec<String>>()
6089                    .join(",")
6090                    .to_string(),
6091            )]),
6092        };
6093    }
6094    if let Some(ref local_var_str) = created_by_request {
6095        local_var_req_builder =
6096            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
6097    }
6098    if let Some(ref local_var_str) = description {
6099        local_var_req_builder = match "multi" {
6100            "multi" => local_var_req_builder.query(
6101                &local_var_str
6102                    .into_iter()
6103                    .map(|p| ("description".to_owned(), p.to_string()))
6104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6105            ),
6106            _ => local_var_req_builder.query(&[(
6107                "description",
6108                &local_var_str
6109                    .into_iter()
6110                    .map(|p| p.to_string())
6111                    .collect::<Vec<String>>()
6112                    .join(",")
6113                    .to_string(),
6114            )]),
6115        };
6116    }
6117    if let Some(ref local_var_str) = description__empty {
6118        local_var_req_builder =
6119            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6120    }
6121    if let Some(ref local_var_str) = description__ic {
6122        local_var_req_builder = match "multi" {
6123            "multi" => local_var_req_builder.query(
6124                &local_var_str
6125                    .into_iter()
6126                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6128            ),
6129            _ => local_var_req_builder.query(&[(
6130                "description__ic",
6131                &local_var_str
6132                    .into_iter()
6133                    .map(|p| p.to_string())
6134                    .collect::<Vec<String>>()
6135                    .join(",")
6136                    .to_string(),
6137            )]),
6138        };
6139    }
6140    if let Some(ref local_var_str) = description__ie {
6141        local_var_req_builder = match "multi" {
6142            "multi" => local_var_req_builder.query(
6143                &local_var_str
6144                    .into_iter()
6145                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6147            ),
6148            _ => local_var_req_builder.query(&[(
6149                "description__ie",
6150                &local_var_str
6151                    .into_iter()
6152                    .map(|p| p.to_string())
6153                    .collect::<Vec<String>>()
6154                    .join(",")
6155                    .to_string(),
6156            )]),
6157        };
6158    }
6159    if let Some(ref local_var_str) = description__iew {
6160        local_var_req_builder = match "multi" {
6161            "multi" => local_var_req_builder.query(
6162                &local_var_str
6163                    .into_iter()
6164                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6166            ),
6167            _ => local_var_req_builder.query(&[(
6168                "description__iew",
6169                &local_var_str
6170                    .into_iter()
6171                    .map(|p| p.to_string())
6172                    .collect::<Vec<String>>()
6173                    .join(",")
6174                    .to_string(),
6175            )]),
6176        };
6177    }
6178    if let Some(ref local_var_str) = description__iregex {
6179        local_var_req_builder = match "multi" {
6180            "multi" => local_var_req_builder.query(
6181                &local_var_str
6182                    .into_iter()
6183                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6185            ),
6186            _ => local_var_req_builder.query(&[(
6187                "description__iregex",
6188                &local_var_str
6189                    .into_iter()
6190                    .map(|p| p.to_string())
6191                    .collect::<Vec<String>>()
6192                    .join(",")
6193                    .to_string(),
6194            )]),
6195        };
6196    }
6197    if let Some(ref local_var_str) = description__isw {
6198        local_var_req_builder = match "multi" {
6199            "multi" => local_var_req_builder.query(
6200                &local_var_str
6201                    .into_iter()
6202                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6204            ),
6205            _ => local_var_req_builder.query(&[(
6206                "description__isw",
6207                &local_var_str
6208                    .into_iter()
6209                    .map(|p| p.to_string())
6210                    .collect::<Vec<String>>()
6211                    .join(",")
6212                    .to_string(),
6213            )]),
6214        };
6215    }
6216    if let Some(ref local_var_str) = description__n {
6217        local_var_req_builder = match "multi" {
6218            "multi" => local_var_req_builder.query(
6219                &local_var_str
6220                    .into_iter()
6221                    .map(|p| ("description__n".to_owned(), p.to_string()))
6222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6223            ),
6224            _ => local_var_req_builder.query(&[(
6225                "description__n",
6226                &local_var_str
6227                    .into_iter()
6228                    .map(|p| p.to_string())
6229                    .collect::<Vec<String>>()
6230                    .join(",")
6231                    .to_string(),
6232            )]),
6233        };
6234    }
6235    if let Some(ref local_var_str) = description__nic {
6236        local_var_req_builder = match "multi" {
6237            "multi" => local_var_req_builder.query(
6238                &local_var_str
6239                    .into_iter()
6240                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6242            ),
6243            _ => local_var_req_builder.query(&[(
6244                "description__nic",
6245                &local_var_str
6246                    .into_iter()
6247                    .map(|p| p.to_string())
6248                    .collect::<Vec<String>>()
6249                    .join(",")
6250                    .to_string(),
6251            )]),
6252        };
6253    }
6254    if let Some(ref local_var_str) = description__nie {
6255        local_var_req_builder = match "multi" {
6256            "multi" => local_var_req_builder.query(
6257                &local_var_str
6258                    .into_iter()
6259                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6261            ),
6262            _ => local_var_req_builder.query(&[(
6263                "description__nie",
6264                &local_var_str
6265                    .into_iter()
6266                    .map(|p| p.to_string())
6267                    .collect::<Vec<String>>()
6268                    .join(",")
6269                    .to_string(),
6270            )]),
6271        };
6272    }
6273    if let Some(ref local_var_str) = description__niew {
6274        local_var_req_builder = match "multi" {
6275            "multi" => local_var_req_builder.query(
6276                &local_var_str
6277                    .into_iter()
6278                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6280            ),
6281            _ => local_var_req_builder.query(&[(
6282                "description__niew",
6283                &local_var_str
6284                    .into_iter()
6285                    .map(|p| p.to_string())
6286                    .collect::<Vec<String>>()
6287                    .join(",")
6288                    .to_string(),
6289            )]),
6290        };
6291    }
6292    if let Some(ref local_var_str) = description__nisw {
6293        local_var_req_builder = match "multi" {
6294            "multi" => local_var_req_builder.query(
6295                &local_var_str
6296                    .into_iter()
6297                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6299            ),
6300            _ => local_var_req_builder.query(&[(
6301                "description__nisw",
6302                &local_var_str
6303                    .into_iter()
6304                    .map(|p| p.to_string())
6305                    .collect::<Vec<String>>()
6306                    .join(",")
6307                    .to_string(),
6308            )]),
6309        };
6310    }
6311    if let Some(ref local_var_str) = description__regex {
6312        local_var_req_builder = match "multi" {
6313            "multi" => local_var_req_builder.query(
6314                &local_var_str
6315                    .into_iter()
6316                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6318            ),
6319            _ => local_var_req_builder.query(&[(
6320                "description__regex",
6321                &local_var_str
6322                    .into_iter()
6323                    .map(|p| p.to_string())
6324                    .collect::<Vec<String>>()
6325                    .join(",")
6326                    .to_string(),
6327            )]),
6328        };
6329    }
6330    if let Some(ref local_var_str) = email {
6331        local_var_req_builder = match "multi" {
6332            "multi" => local_var_req_builder.query(
6333                &local_var_str
6334                    .into_iter()
6335                    .map(|p| ("email".to_owned(), p.to_string()))
6336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6337            ),
6338            _ => local_var_req_builder.query(&[(
6339                "email",
6340                &local_var_str
6341                    .into_iter()
6342                    .map(|p| p.to_string())
6343                    .collect::<Vec<String>>()
6344                    .join(",")
6345                    .to_string(),
6346            )]),
6347        };
6348    }
6349    if let Some(ref local_var_str) = email__empty {
6350        local_var_req_builder =
6351            local_var_req_builder.query(&[("email__empty", &local_var_str.to_string())]);
6352    }
6353    if let Some(ref local_var_str) = email__ic {
6354        local_var_req_builder = match "multi" {
6355            "multi" => local_var_req_builder.query(
6356                &local_var_str
6357                    .into_iter()
6358                    .map(|p| ("email__ic".to_owned(), p.to_string()))
6359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6360            ),
6361            _ => local_var_req_builder.query(&[(
6362                "email__ic",
6363                &local_var_str
6364                    .into_iter()
6365                    .map(|p| p.to_string())
6366                    .collect::<Vec<String>>()
6367                    .join(",")
6368                    .to_string(),
6369            )]),
6370        };
6371    }
6372    if let Some(ref local_var_str) = email__ie {
6373        local_var_req_builder = match "multi" {
6374            "multi" => local_var_req_builder.query(
6375                &local_var_str
6376                    .into_iter()
6377                    .map(|p| ("email__ie".to_owned(), p.to_string()))
6378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6379            ),
6380            _ => local_var_req_builder.query(&[(
6381                "email__ie",
6382                &local_var_str
6383                    .into_iter()
6384                    .map(|p| p.to_string())
6385                    .collect::<Vec<String>>()
6386                    .join(",")
6387                    .to_string(),
6388            )]),
6389        };
6390    }
6391    if let Some(ref local_var_str) = email__iew {
6392        local_var_req_builder = match "multi" {
6393            "multi" => local_var_req_builder.query(
6394                &local_var_str
6395                    .into_iter()
6396                    .map(|p| ("email__iew".to_owned(), p.to_string()))
6397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6398            ),
6399            _ => local_var_req_builder.query(&[(
6400                "email__iew",
6401                &local_var_str
6402                    .into_iter()
6403                    .map(|p| p.to_string())
6404                    .collect::<Vec<String>>()
6405                    .join(",")
6406                    .to_string(),
6407            )]),
6408        };
6409    }
6410    if let Some(ref local_var_str) = email__iregex {
6411        local_var_req_builder = match "multi" {
6412            "multi" => local_var_req_builder.query(
6413                &local_var_str
6414                    .into_iter()
6415                    .map(|p| ("email__iregex".to_owned(), p.to_string()))
6416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6417            ),
6418            _ => local_var_req_builder.query(&[(
6419                "email__iregex",
6420                &local_var_str
6421                    .into_iter()
6422                    .map(|p| p.to_string())
6423                    .collect::<Vec<String>>()
6424                    .join(",")
6425                    .to_string(),
6426            )]),
6427        };
6428    }
6429    if let Some(ref local_var_str) = email__isw {
6430        local_var_req_builder = match "multi" {
6431            "multi" => local_var_req_builder.query(
6432                &local_var_str
6433                    .into_iter()
6434                    .map(|p| ("email__isw".to_owned(), p.to_string()))
6435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6436            ),
6437            _ => local_var_req_builder.query(&[(
6438                "email__isw",
6439                &local_var_str
6440                    .into_iter()
6441                    .map(|p| p.to_string())
6442                    .collect::<Vec<String>>()
6443                    .join(",")
6444                    .to_string(),
6445            )]),
6446        };
6447    }
6448    if let Some(ref local_var_str) = email__n {
6449        local_var_req_builder = match "multi" {
6450            "multi" => local_var_req_builder.query(
6451                &local_var_str
6452                    .into_iter()
6453                    .map(|p| ("email__n".to_owned(), p.to_string()))
6454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6455            ),
6456            _ => local_var_req_builder.query(&[(
6457                "email__n",
6458                &local_var_str
6459                    .into_iter()
6460                    .map(|p| p.to_string())
6461                    .collect::<Vec<String>>()
6462                    .join(",")
6463                    .to_string(),
6464            )]),
6465        };
6466    }
6467    if let Some(ref local_var_str) = email__nic {
6468        local_var_req_builder = match "multi" {
6469            "multi" => local_var_req_builder.query(
6470                &local_var_str
6471                    .into_iter()
6472                    .map(|p| ("email__nic".to_owned(), p.to_string()))
6473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6474            ),
6475            _ => local_var_req_builder.query(&[(
6476                "email__nic",
6477                &local_var_str
6478                    .into_iter()
6479                    .map(|p| p.to_string())
6480                    .collect::<Vec<String>>()
6481                    .join(",")
6482                    .to_string(),
6483            )]),
6484        };
6485    }
6486    if let Some(ref local_var_str) = email__nie {
6487        local_var_req_builder = match "multi" {
6488            "multi" => local_var_req_builder.query(
6489                &local_var_str
6490                    .into_iter()
6491                    .map(|p| ("email__nie".to_owned(), p.to_string()))
6492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6493            ),
6494            _ => local_var_req_builder.query(&[(
6495                "email__nie",
6496                &local_var_str
6497                    .into_iter()
6498                    .map(|p| p.to_string())
6499                    .collect::<Vec<String>>()
6500                    .join(",")
6501                    .to_string(),
6502            )]),
6503        };
6504    }
6505    if let Some(ref local_var_str) = email__niew {
6506        local_var_req_builder = match "multi" {
6507            "multi" => local_var_req_builder.query(
6508                &local_var_str
6509                    .into_iter()
6510                    .map(|p| ("email__niew".to_owned(), p.to_string()))
6511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6512            ),
6513            _ => local_var_req_builder.query(&[(
6514                "email__niew",
6515                &local_var_str
6516                    .into_iter()
6517                    .map(|p| p.to_string())
6518                    .collect::<Vec<String>>()
6519                    .join(",")
6520                    .to_string(),
6521            )]),
6522        };
6523    }
6524    if let Some(ref local_var_str) = email__nisw {
6525        local_var_req_builder = match "multi" {
6526            "multi" => local_var_req_builder.query(
6527                &local_var_str
6528                    .into_iter()
6529                    .map(|p| ("email__nisw".to_owned(), p.to_string()))
6530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6531            ),
6532            _ => local_var_req_builder.query(&[(
6533                "email__nisw",
6534                &local_var_str
6535                    .into_iter()
6536                    .map(|p| p.to_string())
6537                    .collect::<Vec<String>>()
6538                    .join(",")
6539                    .to_string(),
6540            )]),
6541        };
6542    }
6543    if let Some(ref local_var_str) = email__regex {
6544        local_var_req_builder = match "multi" {
6545            "multi" => local_var_req_builder.query(
6546                &local_var_str
6547                    .into_iter()
6548                    .map(|p| ("email__regex".to_owned(), p.to_string()))
6549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6550            ),
6551            _ => local_var_req_builder.query(&[(
6552                "email__regex",
6553                &local_var_str
6554                    .into_iter()
6555                    .map(|p| p.to_string())
6556                    .collect::<Vec<String>>()
6557                    .join(",")
6558                    .to_string(),
6559            )]),
6560        };
6561    }
6562    if let Some(ref local_var_str) = group {
6563        local_var_req_builder = match "multi" {
6564            "multi" => local_var_req_builder.query(
6565                &local_var_str
6566                    .into_iter()
6567                    .map(|p| ("group".to_owned(), p.to_string()))
6568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6569            ),
6570            _ => local_var_req_builder.query(&[(
6571                "group",
6572                &local_var_str
6573                    .into_iter()
6574                    .map(|p| p.to_string())
6575                    .collect::<Vec<String>>()
6576                    .join(",")
6577                    .to_string(),
6578            )]),
6579        };
6580    }
6581    if let Some(ref local_var_str) = group__n {
6582        local_var_req_builder = match "multi" {
6583            "multi" => local_var_req_builder.query(
6584                &local_var_str
6585                    .into_iter()
6586                    .map(|p| ("group__n".to_owned(), p.to_string()))
6587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6588            ),
6589            _ => local_var_req_builder.query(&[(
6590                "group__n",
6591                &local_var_str
6592                    .into_iter()
6593                    .map(|p| p.to_string())
6594                    .collect::<Vec<String>>()
6595                    .join(",")
6596                    .to_string(),
6597            )]),
6598        };
6599    }
6600    if let Some(ref local_var_str) = group_id {
6601        local_var_req_builder = match "multi" {
6602            "multi" => local_var_req_builder.query(
6603                &local_var_str
6604                    .into_iter()
6605                    .map(|p| ("group_id".to_owned(), p.to_string()))
6606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6607            ),
6608            _ => local_var_req_builder.query(&[(
6609                "group_id",
6610                &local_var_str
6611                    .into_iter()
6612                    .map(|p| p.to_string())
6613                    .collect::<Vec<String>>()
6614                    .join(",")
6615                    .to_string(),
6616            )]),
6617        };
6618    }
6619    if let Some(ref local_var_str) = group_id__n {
6620        local_var_req_builder = match "multi" {
6621            "multi" => local_var_req_builder.query(
6622                &local_var_str
6623                    .into_iter()
6624                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
6625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6626            ),
6627            _ => local_var_req_builder.query(&[(
6628                "group_id__n",
6629                &local_var_str
6630                    .into_iter()
6631                    .map(|p| p.to_string())
6632                    .collect::<Vec<String>>()
6633                    .join(",")
6634                    .to_string(),
6635            )]),
6636        };
6637    }
6638    if let Some(ref local_var_str) = id {
6639        local_var_req_builder = match "multi" {
6640            "multi" => local_var_req_builder.query(
6641                &local_var_str
6642                    .into_iter()
6643                    .map(|p| ("id".to_owned(), p.to_string()))
6644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6645            ),
6646            _ => local_var_req_builder.query(&[(
6647                "id",
6648                &local_var_str
6649                    .into_iter()
6650                    .map(|p| p.to_string())
6651                    .collect::<Vec<String>>()
6652                    .join(",")
6653                    .to_string(),
6654            )]),
6655        };
6656    }
6657    if let Some(ref local_var_str) = id__empty {
6658        local_var_req_builder =
6659            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6660    }
6661    if let Some(ref local_var_str) = id__gt {
6662        local_var_req_builder = match "multi" {
6663            "multi" => local_var_req_builder.query(
6664                &local_var_str
6665                    .into_iter()
6666                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6668            ),
6669            _ => local_var_req_builder.query(&[(
6670                "id__gt",
6671                &local_var_str
6672                    .into_iter()
6673                    .map(|p| p.to_string())
6674                    .collect::<Vec<String>>()
6675                    .join(",")
6676                    .to_string(),
6677            )]),
6678        };
6679    }
6680    if let Some(ref local_var_str) = id__gte {
6681        local_var_req_builder = match "multi" {
6682            "multi" => local_var_req_builder.query(
6683                &local_var_str
6684                    .into_iter()
6685                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6687            ),
6688            _ => local_var_req_builder.query(&[(
6689                "id__gte",
6690                &local_var_str
6691                    .into_iter()
6692                    .map(|p| p.to_string())
6693                    .collect::<Vec<String>>()
6694                    .join(",")
6695                    .to_string(),
6696            )]),
6697        };
6698    }
6699    if let Some(ref local_var_str) = id__lt {
6700        local_var_req_builder = match "multi" {
6701            "multi" => local_var_req_builder.query(
6702                &local_var_str
6703                    .into_iter()
6704                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6706            ),
6707            _ => local_var_req_builder.query(&[(
6708                "id__lt",
6709                &local_var_str
6710                    .into_iter()
6711                    .map(|p| p.to_string())
6712                    .collect::<Vec<String>>()
6713                    .join(",")
6714                    .to_string(),
6715            )]),
6716        };
6717    }
6718    if let Some(ref local_var_str) = id__lte {
6719        local_var_req_builder = match "multi" {
6720            "multi" => local_var_req_builder.query(
6721                &local_var_str
6722                    .into_iter()
6723                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6725            ),
6726            _ => local_var_req_builder.query(&[(
6727                "id__lte",
6728                &local_var_str
6729                    .into_iter()
6730                    .map(|p| p.to_string())
6731                    .collect::<Vec<String>>()
6732                    .join(",")
6733                    .to_string(),
6734            )]),
6735        };
6736    }
6737    if let Some(ref local_var_str) = id__n {
6738        local_var_req_builder = match "multi" {
6739            "multi" => local_var_req_builder.query(
6740                &local_var_str
6741                    .into_iter()
6742                    .map(|p| ("id__n".to_owned(), p.to_string()))
6743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6744            ),
6745            _ => local_var_req_builder.query(&[(
6746                "id__n",
6747                &local_var_str
6748                    .into_iter()
6749                    .map(|p| p.to_string())
6750                    .collect::<Vec<String>>()
6751                    .join(",")
6752                    .to_string(),
6753            )]),
6754        };
6755    }
6756    if let Some(ref local_var_str) = last_updated {
6757        local_var_req_builder = match "multi" {
6758            "multi" => local_var_req_builder.query(
6759                &local_var_str
6760                    .into_iter()
6761                    .map(|p| ("last_updated".to_owned(), p.to_string()))
6762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6763            ),
6764            _ => local_var_req_builder.query(&[(
6765                "last_updated",
6766                &local_var_str
6767                    .into_iter()
6768                    .map(|p| p.to_string())
6769                    .collect::<Vec<String>>()
6770                    .join(",")
6771                    .to_string(),
6772            )]),
6773        };
6774    }
6775    if let Some(ref local_var_str) = last_updated__empty {
6776        local_var_req_builder = match "multi" {
6777            "multi" => local_var_req_builder.query(
6778                &local_var_str
6779                    .into_iter()
6780                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
6781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6782            ),
6783            _ => local_var_req_builder.query(&[(
6784                "last_updated__empty",
6785                &local_var_str
6786                    .into_iter()
6787                    .map(|p| p.to_string())
6788                    .collect::<Vec<String>>()
6789                    .join(",")
6790                    .to_string(),
6791            )]),
6792        };
6793    }
6794    if let Some(ref local_var_str) = last_updated__gt {
6795        local_var_req_builder = match "multi" {
6796            "multi" => local_var_req_builder.query(
6797                &local_var_str
6798                    .into_iter()
6799                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
6800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6801            ),
6802            _ => local_var_req_builder.query(&[(
6803                "last_updated__gt",
6804                &local_var_str
6805                    .into_iter()
6806                    .map(|p| p.to_string())
6807                    .collect::<Vec<String>>()
6808                    .join(",")
6809                    .to_string(),
6810            )]),
6811        };
6812    }
6813    if let Some(ref local_var_str) = last_updated__gte {
6814        local_var_req_builder = match "multi" {
6815            "multi" => local_var_req_builder.query(
6816                &local_var_str
6817                    .into_iter()
6818                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
6819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6820            ),
6821            _ => local_var_req_builder.query(&[(
6822                "last_updated__gte",
6823                &local_var_str
6824                    .into_iter()
6825                    .map(|p| p.to_string())
6826                    .collect::<Vec<String>>()
6827                    .join(",")
6828                    .to_string(),
6829            )]),
6830        };
6831    }
6832    if let Some(ref local_var_str) = last_updated__lt {
6833        local_var_req_builder = match "multi" {
6834            "multi" => local_var_req_builder.query(
6835                &local_var_str
6836                    .into_iter()
6837                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
6838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6839            ),
6840            _ => local_var_req_builder.query(&[(
6841                "last_updated__lt",
6842                &local_var_str
6843                    .into_iter()
6844                    .map(|p| p.to_string())
6845                    .collect::<Vec<String>>()
6846                    .join(",")
6847                    .to_string(),
6848            )]),
6849        };
6850    }
6851    if let Some(ref local_var_str) = last_updated__lte {
6852        local_var_req_builder = match "multi" {
6853            "multi" => local_var_req_builder.query(
6854                &local_var_str
6855                    .into_iter()
6856                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
6857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6858            ),
6859            _ => local_var_req_builder.query(&[(
6860                "last_updated__lte",
6861                &local_var_str
6862                    .into_iter()
6863                    .map(|p| p.to_string())
6864                    .collect::<Vec<String>>()
6865                    .join(",")
6866                    .to_string(),
6867            )]),
6868        };
6869    }
6870    if let Some(ref local_var_str) = last_updated__n {
6871        local_var_req_builder = match "multi" {
6872            "multi" => local_var_req_builder.query(
6873                &local_var_str
6874                    .into_iter()
6875                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
6876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6877            ),
6878            _ => local_var_req_builder.query(&[(
6879                "last_updated__n",
6880                &local_var_str
6881                    .into_iter()
6882                    .map(|p| p.to_string())
6883                    .collect::<Vec<String>>()
6884                    .join(",")
6885                    .to_string(),
6886            )]),
6887        };
6888    }
6889    if let Some(ref local_var_str) = limit {
6890        local_var_req_builder =
6891            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6892    }
6893    if let Some(ref local_var_str) = link {
6894        local_var_req_builder = match "multi" {
6895            "multi" => local_var_req_builder.query(
6896                &local_var_str
6897                    .into_iter()
6898                    .map(|p| ("link".to_owned(), p.to_string()))
6899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6900            ),
6901            _ => local_var_req_builder.query(&[(
6902                "link",
6903                &local_var_str
6904                    .into_iter()
6905                    .map(|p| p.to_string())
6906                    .collect::<Vec<String>>()
6907                    .join(",")
6908                    .to_string(),
6909            )]),
6910        };
6911    }
6912    if let Some(ref local_var_str) = link__empty {
6913        local_var_req_builder =
6914            local_var_req_builder.query(&[("link__empty", &local_var_str.to_string())]);
6915    }
6916    if let Some(ref local_var_str) = link__ic {
6917        local_var_req_builder = match "multi" {
6918            "multi" => local_var_req_builder.query(
6919                &local_var_str
6920                    .into_iter()
6921                    .map(|p| ("link__ic".to_owned(), p.to_string()))
6922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6923            ),
6924            _ => local_var_req_builder.query(&[(
6925                "link__ic",
6926                &local_var_str
6927                    .into_iter()
6928                    .map(|p| p.to_string())
6929                    .collect::<Vec<String>>()
6930                    .join(",")
6931                    .to_string(),
6932            )]),
6933        };
6934    }
6935    if let Some(ref local_var_str) = link__ie {
6936        local_var_req_builder = match "multi" {
6937            "multi" => local_var_req_builder.query(
6938                &local_var_str
6939                    .into_iter()
6940                    .map(|p| ("link__ie".to_owned(), p.to_string()))
6941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6942            ),
6943            _ => local_var_req_builder.query(&[(
6944                "link__ie",
6945                &local_var_str
6946                    .into_iter()
6947                    .map(|p| p.to_string())
6948                    .collect::<Vec<String>>()
6949                    .join(",")
6950                    .to_string(),
6951            )]),
6952        };
6953    }
6954    if let Some(ref local_var_str) = link__iew {
6955        local_var_req_builder = match "multi" {
6956            "multi" => local_var_req_builder.query(
6957                &local_var_str
6958                    .into_iter()
6959                    .map(|p| ("link__iew".to_owned(), p.to_string()))
6960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6961            ),
6962            _ => local_var_req_builder.query(&[(
6963                "link__iew",
6964                &local_var_str
6965                    .into_iter()
6966                    .map(|p| p.to_string())
6967                    .collect::<Vec<String>>()
6968                    .join(",")
6969                    .to_string(),
6970            )]),
6971        };
6972    }
6973    if let Some(ref local_var_str) = link__iregex {
6974        local_var_req_builder = match "multi" {
6975            "multi" => local_var_req_builder.query(
6976                &local_var_str
6977                    .into_iter()
6978                    .map(|p| ("link__iregex".to_owned(), p.to_string()))
6979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6980            ),
6981            _ => local_var_req_builder.query(&[(
6982                "link__iregex",
6983                &local_var_str
6984                    .into_iter()
6985                    .map(|p| p.to_string())
6986                    .collect::<Vec<String>>()
6987                    .join(",")
6988                    .to_string(),
6989            )]),
6990        };
6991    }
6992    if let Some(ref local_var_str) = link__isw {
6993        local_var_req_builder = match "multi" {
6994            "multi" => local_var_req_builder.query(
6995                &local_var_str
6996                    .into_iter()
6997                    .map(|p| ("link__isw".to_owned(), p.to_string()))
6998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6999            ),
7000            _ => local_var_req_builder.query(&[(
7001                "link__isw",
7002                &local_var_str
7003                    .into_iter()
7004                    .map(|p| p.to_string())
7005                    .collect::<Vec<String>>()
7006                    .join(",")
7007                    .to_string(),
7008            )]),
7009        };
7010    }
7011    if let Some(ref local_var_str) = link__n {
7012        local_var_req_builder = match "multi" {
7013            "multi" => local_var_req_builder.query(
7014                &local_var_str
7015                    .into_iter()
7016                    .map(|p| ("link__n".to_owned(), p.to_string()))
7017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7018            ),
7019            _ => local_var_req_builder.query(&[(
7020                "link__n",
7021                &local_var_str
7022                    .into_iter()
7023                    .map(|p| p.to_string())
7024                    .collect::<Vec<String>>()
7025                    .join(",")
7026                    .to_string(),
7027            )]),
7028        };
7029    }
7030    if let Some(ref local_var_str) = link__nic {
7031        local_var_req_builder = match "multi" {
7032            "multi" => local_var_req_builder.query(
7033                &local_var_str
7034                    .into_iter()
7035                    .map(|p| ("link__nic".to_owned(), p.to_string()))
7036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7037            ),
7038            _ => local_var_req_builder.query(&[(
7039                "link__nic",
7040                &local_var_str
7041                    .into_iter()
7042                    .map(|p| p.to_string())
7043                    .collect::<Vec<String>>()
7044                    .join(",")
7045                    .to_string(),
7046            )]),
7047        };
7048    }
7049    if let Some(ref local_var_str) = link__nie {
7050        local_var_req_builder = match "multi" {
7051            "multi" => local_var_req_builder.query(
7052                &local_var_str
7053                    .into_iter()
7054                    .map(|p| ("link__nie".to_owned(), p.to_string()))
7055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7056            ),
7057            _ => local_var_req_builder.query(&[(
7058                "link__nie",
7059                &local_var_str
7060                    .into_iter()
7061                    .map(|p| p.to_string())
7062                    .collect::<Vec<String>>()
7063                    .join(",")
7064                    .to_string(),
7065            )]),
7066        };
7067    }
7068    if let Some(ref local_var_str) = link__niew {
7069        local_var_req_builder = match "multi" {
7070            "multi" => local_var_req_builder.query(
7071                &local_var_str
7072                    .into_iter()
7073                    .map(|p| ("link__niew".to_owned(), p.to_string()))
7074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7075            ),
7076            _ => local_var_req_builder.query(&[(
7077                "link__niew",
7078                &local_var_str
7079                    .into_iter()
7080                    .map(|p| p.to_string())
7081                    .collect::<Vec<String>>()
7082                    .join(",")
7083                    .to_string(),
7084            )]),
7085        };
7086    }
7087    if let Some(ref local_var_str) = link__nisw {
7088        local_var_req_builder = match "multi" {
7089            "multi" => local_var_req_builder.query(
7090                &local_var_str
7091                    .into_iter()
7092                    .map(|p| ("link__nisw".to_owned(), p.to_string()))
7093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7094            ),
7095            _ => local_var_req_builder.query(&[(
7096                "link__nisw",
7097                &local_var_str
7098                    .into_iter()
7099                    .map(|p| p.to_string())
7100                    .collect::<Vec<String>>()
7101                    .join(",")
7102                    .to_string(),
7103            )]),
7104        };
7105    }
7106    if let Some(ref local_var_str) = link__regex {
7107        local_var_req_builder = match "multi" {
7108            "multi" => local_var_req_builder.query(
7109                &local_var_str
7110                    .into_iter()
7111                    .map(|p| ("link__regex".to_owned(), p.to_string()))
7112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7113            ),
7114            _ => local_var_req_builder.query(&[(
7115                "link__regex",
7116                &local_var_str
7117                    .into_iter()
7118                    .map(|p| p.to_string())
7119                    .collect::<Vec<String>>()
7120                    .join(",")
7121                    .to_string(),
7122            )]),
7123        };
7124    }
7125    if let Some(ref local_var_str) = modified_by_request {
7126        local_var_req_builder =
7127            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
7128    }
7129    if let Some(ref local_var_str) = name {
7130        local_var_req_builder = match "multi" {
7131            "multi" => local_var_req_builder.query(
7132                &local_var_str
7133                    .into_iter()
7134                    .map(|p| ("name".to_owned(), p.to_string()))
7135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7136            ),
7137            _ => local_var_req_builder.query(&[(
7138                "name",
7139                &local_var_str
7140                    .into_iter()
7141                    .map(|p| p.to_string())
7142                    .collect::<Vec<String>>()
7143                    .join(",")
7144                    .to_string(),
7145            )]),
7146        };
7147    }
7148    if let Some(ref local_var_str) = name__empty {
7149        local_var_req_builder =
7150            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
7151    }
7152    if let Some(ref local_var_str) = name__ic {
7153        local_var_req_builder = match "multi" {
7154            "multi" => local_var_req_builder.query(
7155                &local_var_str
7156                    .into_iter()
7157                    .map(|p| ("name__ic".to_owned(), p.to_string()))
7158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7159            ),
7160            _ => local_var_req_builder.query(&[(
7161                "name__ic",
7162                &local_var_str
7163                    .into_iter()
7164                    .map(|p| p.to_string())
7165                    .collect::<Vec<String>>()
7166                    .join(",")
7167                    .to_string(),
7168            )]),
7169        };
7170    }
7171    if let Some(ref local_var_str) = name__ie {
7172        local_var_req_builder = match "multi" {
7173            "multi" => local_var_req_builder.query(
7174                &local_var_str
7175                    .into_iter()
7176                    .map(|p| ("name__ie".to_owned(), p.to_string()))
7177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7178            ),
7179            _ => local_var_req_builder.query(&[(
7180                "name__ie",
7181                &local_var_str
7182                    .into_iter()
7183                    .map(|p| p.to_string())
7184                    .collect::<Vec<String>>()
7185                    .join(",")
7186                    .to_string(),
7187            )]),
7188        };
7189    }
7190    if let Some(ref local_var_str) = name__iew {
7191        local_var_req_builder = match "multi" {
7192            "multi" => local_var_req_builder.query(
7193                &local_var_str
7194                    .into_iter()
7195                    .map(|p| ("name__iew".to_owned(), p.to_string()))
7196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7197            ),
7198            _ => local_var_req_builder.query(&[(
7199                "name__iew",
7200                &local_var_str
7201                    .into_iter()
7202                    .map(|p| p.to_string())
7203                    .collect::<Vec<String>>()
7204                    .join(",")
7205                    .to_string(),
7206            )]),
7207        };
7208    }
7209    if let Some(ref local_var_str) = name__iregex {
7210        local_var_req_builder = match "multi" {
7211            "multi" => local_var_req_builder.query(
7212                &local_var_str
7213                    .into_iter()
7214                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
7215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7216            ),
7217            _ => local_var_req_builder.query(&[(
7218                "name__iregex",
7219                &local_var_str
7220                    .into_iter()
7221                    .map(|p| p.to_string())
7222                    .collect::<Vec<String>>()
7223                    .join(",")
7224                    .to_string(),
7225            )]),
7226        };
7227    }
7228    if let Some(ref local_var_str) = name__isw {
7229        local_var_req_builder = match "multi" {
7230            "multi" => local_var_req_builder.query(
7231                &local_var_str
7232                    .into_iter()
7233                    .map(|p| ("name__isw".to_owned(), p.to_string()))
7234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7235            ),
7236            _ => local_var_req_builder.query(&[(
7237                "name__isw",
7238                &local_var_str
7239                    .into_iter()
7240                    .map(|p| p.to_string())
7241                    .collect::<Vec<String>>()
7242                    .join(",")
7243                    .to_string(),
7244            )]),
7245        };
7246    }
7247    if let Some(ref local_var_str) = name__n {
7248        local_var_req_builder = match "multi" {
7249            "multi" => local_var_req_builder.query(
7250                &local_var_str
7251                    .into_iter()
7252                    .map(|p| ("name__n".to_owned(), p.to_string()))
7253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7254            ),
7255            _ => local_var_req_builder.query(&[(
7256                "name__n",
7257                &local_var_str
7258                    .into_iter()
7259                    .map(|p| p.to_string())
7260                    .collect::<Vec<String>>()
7261                    .join(",")
7262                    .to_string(),
7263            )]),
7264        };
7265    }
7266    if let Some(ref local_var_str) = name__nic {
7267        local_var_req_builder = match "multi" {
7268            "multi" => local_var_req_builder.query(
7269                &local_var_str
7270                    .into_iter()
7271                    .map(|p| ("name__nic".to_owned(), p.to_string()))
7272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7273            ),
7274            _ => local_var_req_builder.query(&[(
7275                "name__nic",
7276                &local_var_str
7277                    .into_iter()
7278                    .map(|p| p.to_string())
7279                    .collect::<Vec<String>>()
7280                    .join(",")
7281                    .to_string(),
7282            )]),
7283        };
7284    }
7285    if let Some(ref local_var_str) = name__nie {
7286        local_var_req_builder = match "multi" {
7287            "multi" => local_var_req_builder.query(
7288                &local_var_str
7289                    .into_iter()
7290                    .map(|p| ("name__nie".to_owned(), p.to_string()))
7291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7292            ),
7293            _ => local_var_req_builder.query(&[(
7294                "name__nie",
7295                &local_var_str
7296                    .into_iter()
7297                    .map(|p| p.to_string())
7298                    .collect::<Vec<String>>()
7299                    .join(",")
7300                    .to_string(),
7301            )]),
7302        };
7303    }
7304    if let Some(ref local_var_str) = name__niew {
7305        local_var_req_builder = match "multi" {
7306            "multi" => local_var_req_builder.query(
7307                &local_var_str
7308                    .into_iter()
7309                    .map(|p| ("name__niew".to_owned(), p.to_string()))
7310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7311            ),
7312            _ => local_var_req_builder.query(&[(
7313                "name__niew",
7314                &local_var_str
7315                    .into_iter()
7316                    .map(|p| p.to_string())
7317                    .collect::<Vec<String>>()
7318                    .join(",")
7319                    .to_string(),
7320            )]),
7321        };
7322    }
7323    if let Some(ref local_var_str) = name__nisw {
7324        local_var_req_builder = match "multi" {
7325            "multi" => local_var_req_builder.query(
7326                &local_var_str
7327                    .into_iter()
7328                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
7329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7330            ),
7331            _ => local_var_req_builder.query(&[(
7332                "name__nisw",
7333                &local_var_str
7334                    .into_iter()
7335                    .map(|p| p.to_string())
7336                    .collect::<Vec<String>>()
7337                    .join(",")
7338                    .to_string(),
7339            )]),
7340        };
7341    }
7342    if let Some(ref local_var_str) = name__regex {
7343        local_var_req_builder = match "multi" {
7344            "multi" => local_var_req_builder.query(
7345                &local_var_str
7346                    .into_iter()
7347                    .map(|p| ("name__regex".to_owned(), p.to_string()))
7348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7349            ),
7350            _ => local_var_req_builder.query(&[(
7351                "name__regex",
7352                &local_var_str
7353                    .into_iter()
7354                    .map(|p| p.to_string())
7355                    .collect::<Vec<String>>()
7356                    .join(",")
7357                    .to_string(),
7358            )]),
7359        };
7360    }
7361    if let Some(ref local_var_str) = offset {
7362        local_var_req_builder =
7363            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7364    }
7365    if let Some(ref local_var_str) = ordering {
7366        local_var_req_builder =
7367            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
7368    }
7369    if let Some(ref local_var_str) = phone {
7370        local_var_req_builder = match "multi" {
7371            "multi" => local_var_req_builder.query(
7372                &local_var_str
7373                    .into_iter()
7374                    .map(|p| ("phone".to_owned(), p.to_string()))
7375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7376            ),
7377            _ => local_var_req_builder.query(&[(
7378                "phone",
7379                &local_var_str
7380                    .into_iter()
7381                    .map(|p| p.to_string())
7382                    .collect::<Vec<String>>()
7383                    .join(",")
7384                    .to_string(),
7385            )]),
7386        };
7387    }
7388    if let Some(ref local_var_str) = phone__empty {
7389        local_var_req_builder =
7390            local_var_req_builder.query(&[("phone__empty", &local_var_str.to_string())]);
7391    }
7392    if let Some(ref local_var_str) = phone__ic {
7393        local_var_req_builder = match "multi" {
7394            "multi" => local_var_req_builder.query(
7395                &local_var_str
7396                    .into_iter()
7397                    .map(|p| ("phone__ic".to_owned(), p.to_string()))
7398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7399            ),
7400            _ => local_var_req_builder.query(&[(
7401                "phone__ic",
7402                &local_var_str
7403                    .into_iter()
7404                    .map(|p| p.to_string())
7405                    .collect::<Vec<String>>()
7406                    .join(",")
7407                    .to_string(),
7408            )]),
7409        };
7410    }
7411    if let Some(ref local_var_str) = phone__ie {
7412        local_var_req_builder = match "multi" {
7413            "multi" => local_var_req_builder.query(
7414                &local_var_str
7415                    .into_iter()
7416                    .map(|p| ("phone__ie".to_owned(), p.to_string()))
7417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7418            ),
7419            _ => local_var_req_builder.query(&[(
7420                "phone__ie",
7421                &local_var_str
7422                    .into_iter()
7423                    .map(|p| p.to_string())
7424                    .collect::<Vec<String>>()
7425                    .join(",")
7426                    .to_string(),
7427            )]),
7428        };
7429    }
7430    if let Some(ref local_var_str) = phone__iew {
7431        local_var_req_builder = match "multi" {
7432            "multi" => local_var_req_builder.query(
7433                &local_var_str
7434                    .into_iter()
7435                    .map(|p| ("phone__iew".to_owned(), p.to_string()))
7436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7437            ),
7438            _ => local_var_req_builder.query(&[(
7439                "phone__iew",
7440                &local_var_str
7441                    .into_iter()
7442                    .map(|p| p.to_string())
7443                    .collect::<Vec<String>>()
7444                    .join(",")
7445                    .to_string(),
7446            )]),
7447        };
7448    }
7449    if let Some(ref local_var_str) = phone__iregex {
7450        local_var_req_builder = match "multi" {
7451            "multi" => local_var_req_builder.query(
7452                &local_var_str
7453                    .into_iter()
7454                    .map(|p| ("phone__iregex".to_owned(), p.to_string()))
7455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7456            ),
7457            _ => local_var_req_builder.query(&[(
7458                "phone__iregex",
7459                &local_var_str
7460                    .into_iter()
7461                    .map(|p| p.to_string())
7462                    .collect::<Vec<String>>()
7463                    .join(",")
7464                    .to_string(),
7465            )]),
7466        };
7467    }
7468    if let Some(ref local_var_str) = phone__isw {
7469        local_var_req_builder = match "multi" {
7470            "multi" => local_var_req_builder.query(
7471                &local_var_str
7472                    .into_iter()
7473                    .map(|p| ("phone__isw".to_owned(), p.to_string()))
7474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7475            ),
7476            _ => local_var_req_builder.query(&[(
7477                "phone__isw",
7478                &local_var_str
7479                    .into_iter()
7480                    .map(|p| p.to_string())
7481                    .collect::<Vec<String>>()
7482                    .join(",")
7483                    .to_string(),
7484            )]),
7485        };
7486    }
7487    if let Some(ref local_var_str) = phone__n {
7488        local_var_req_builder = match "multi" {
7489            "multi" => local_var_req_builder.query(
7490                &local_var_str
7491                    .into_iter()
7492                    .map(|p| ("phone__n".to_owned(), p.to_string()))
7493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7494            ),
7495            _ => local_var_req_builder.query(&[(
7496                "phone__n",
7497                &local_var_str
7498                    .into_iter()
7499                    .map(|p| p.to_string())
7500                    .collect::<Vec<String>>()
7501                    .join(",")
7502                    .to_string(),
7503            )]),
7504        };
7505    }
7506    if let Some(ref local_var_str) = phone__nic {
7507        local_var_req_builder = match "multi" {
7508            "multi" => local_var_req_builder.query(
7509                &local_var_str
7510                    .into_iter()
7511                    .map(|p| ("phone__nic".to_owned(), p.to_string()))
7512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7513            ),
7514            _ => local_var_req_builder.query(&[(
7515                "phone__nic",
7516                &local_var_str
7517                    .into_iter()
7518                    .map(|p| p.to_string())
7519                    .collect::<Vec<String>>()
7520                    .join(",")
7521                    .to_string(),
7522            )]),
7523        };
7524    }
7525    if let Some(ref local_var_str) = phone__nie {
7526        local_var_req_builder = match "multi" {
7527            "multi" => local_var_req_builder.query(
7528                &local_var_str
7529                    .into_iter()
7530                    .map(|p| ("phone__nie".to_owned(), p.to_string()))
7531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7532            ),
7533            _ => local_var_req_builder.query(&[(
7534                "phone__nie",
7535                &local_var_str
7536                    .into_iter()
7537                    .map(|p| p.to_string())
7538                    .collect::<Vec<String>>()
7539                    .join(",")
7540                    .to_string(),
7541            )]),
7542        };
7543    }
7544    if let Some(ref local_var_str) = phone__niew {
7545        local_var_req_builder = match "multi" {
7546            "multi" => local_var_req_builder.query(
7547                &local_var_str
7548                    .into_iter()
7549                    .map(|p| ("phone__niew".to_owned(), p.to_string()))
7550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7551            ),
7552            _ => local_var_req_builder.query(&[(
7553                "phone__niew",
7554                &local_var_str
7555                    .into_iter()
7556                    .map(|p| p.to_string())
7557                    .collect::<Vec<String>>()
7558                    .join(",")
7559                    .to_string(),
7560            )]),
7561        };
7562    }
7563    if let Some(ref local_var_str) = phone__nisw {
7564        local_var_req_builder = match "multi" {
7565            "multi" => local_var_req_builder.query(
7566                &local_var_str
7567                    .into_iter()
7568                    .map(|p| ("phone__nisw".to_owned(), p.to_string()))
7569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7570            ),
7571            _ => local_var_req_builder.query(&[(
7572                "phone__nisw",
7573                &local_var_str
7574                    .into_iter()
7575                    .map(|p| p.to_string())
7576                    .collect::<Vec<String>>()
7577                    .join(",")
7578                    .to_string(),
7579            )]),
7580        };
7581    }
7582    if let Some(ref local_var_str) = phone__regex {
7583        local_var_req_builder = match "multi" {
7584            "multi" => local_var_req_builder.query(
7585                &local_var_str
7586                    .into_iter()
7587                    .map(|p| ("phone__regex".to_owned(), p.to_string()))
7588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7589            ),
7590            _ => local_var_req_builder.query(&[(
7591                "phone__regex",
7592                &local_var_str
7593                    .into_iter()
7594                    .map(|p| p.to_string())
7595                    .collect::<Vec<String>>()
7596                    .join(",")
7597                    .to_string(),
7598            )]),
7599        };
7600    }
7601    if let Some(ref local_var_str) = q {
7602        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
7603    }
7604    if let Some(ref local_var_str) = tag {
7605        local_var_req_builder = match "multi" {
7606            "multi" => local_var_req_builder.query(
7607                &local_var_str
7608                    .into_iter()
7609                    .map(|p| ("tag".to_owned(), p.to_string()))
7610                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7611            ),
7612            _ => local_var_req_builder.query(&[(
7613                "tag",
7614                &local_var_str
7615                    .into_iter()
7616                    .map(|p| p.to_string())
7617                    .collect::<Vec<String>>()
7618                    .join(",")
7619                    .to_string(),
7620            )]),
7621        };
7622    }
7623    if let Some(ref local_var_str) = tag__n {
7624        local_var_req_builder = match "multi" {
7625            "multi" => local_var_req_builder.query(
7626                &local_var_str
7627                    .into_iter()
7628                    .map(|p| ("tag__n".to_owned(), p.to_string()))
7629                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7630            ),
7631            _ => local_var_req_builder.query(&[(
7632                "tag__n",
7633                &local_var_str
7634                    .into_iter()
7635                    .map(|p| p.to_string())
7636                    .collect::<Vec<String>>()
7637                    .join(",")
7638                    .to_string(),
7639            )]),
7640        };
7641    }
7642    if let Some(ref local_var_str) = tag_id {
7643        local_var_req_builder = match "multi" {
7644            "multi" => local_var_req_builder.query(
7645                &local_var_str
7646                    .into_iter()
7647                    .map(|p| ("tag_id".to_owned(), p.to_string()))
7648                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7649            ),
7650            _ => local_var_req_builder.query(&[(
7651                "tag_id",
7652                &local_var_str
7653                    .into_iter()
7654                    .map(|p| p.to_string())
7655                    .collect::<Vec<String>>()
7656                    .join(",")
7657                    .to_string(),
7658            )]),
7659        };
7660    }
7661    if let Some(ref local_var_str) = tag_id__n {
7662        local_var_req_builder = match "multi" {
7663            "multi" => local_var_req_builder.query(
7664                &local_var_str
7665                    .into_iter()
7666                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
7667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7668            ),
7669            _ => local_var_req_builder.query(&[(
7670                "tag_id__n",
7671                &local_var_str
7672                    .into_iter()
7673                    .map(|p| p.to_string())
7674                    .collect::<Vec<String>>()
7675                    .join(",")
7676                    .to_string(),
7677            )]),
7678        };
7679    }
7680    if let Some(ref local_var_str) = title {
7681        local_var_req_builder = match "multi" {
7682            "multi" => local_var_req_builder.query(
7683                &local_var_str
7684                    .into_iter()
7685                    .map(|p| ("title".to_owned(), p.to_string()))
7686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7687            ),
7688            _ => local_var_req_builder.query(&[(
7689                "title",
7690                &local_var_str
7691                    .into_iter()
7692                    .map(|p| p.to_string())
7693                    .collect::<Vec<String>>()
7694                    .join(",")
7695                    .to_string(),
7696            )]),
7697        };
7698    }
7699    if let Some(ref local_var_str) = title__empty {
7700        local_var_req_builder =
7701            local_var_req_builder.query(&[("title__empty", &local_var_str.to_string())]);
7702    }
7703    if let Some(ref local_var_str) = title__ic {
7704        local_var_req_builder = match "multi" {
7705            "multi" => local_var_req_builder.query(
7706                &local_var_str
7707                    .into_iter()
7708                    .map(|p| ("title__ic".to_owned(), p.to_string()))
7709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7710            ),
7711            _ => local_var_req_builder.query(&[(
7712                "title__ic",
7713                &local_var_str
7714                    .into_iter()
7715                    .map(|p| p.to_string())
7716                    .collect::<Vec<String>>()
7717                    .join(",")
7718                    .to_string(),
7719            )]),
7720        };
7721    }
7722    if let Some(ref local_var_str) = title__ie {
7723        local_var_req_builder = match "multi" {
7724            "multi" => local_var_req_builder.query(
7725                &local_var_str
7726                    .into_iter()
7727                    .map(|p| ("title__ie".to_owned(), p.to_string()))
7728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7729            ),
7730            _ => local_var_req_builder.query(&[(
7731                "title__ie",
7732                &local_var_str
7733                    .into_iter()
7734                    .map(|p| p.to_string())
7735                    .collect::<Vec<String>>()
7736                    .join(",")
7737                    .to_string(),
7738            )]),
7739        };
7740    }
7741    if let Some(ref local_var_str) = title__iew {
7742        local_var_req_builder = match "multi" {
7743            "multi" => local_var_req_builder.query(
7744                &local_var_str
7745                    .into_iter()
7746                    .map(|p| ("title__iew".to_owned(), p.to_string()))
7747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7748            ),
7749            _ => local_var_req_builder.query(&[(
7750                "title__iew",
7751                &local_var_str
7752                    .into_iter()
7753                    .map(|p| p.to_string())
7754                    .collect::<Vec<String>>()
7755                    .join(",")
7756                    .to_string(),
7757            )]),
7758        };
7759    }
7760    if let Some(ref local_var_str) = title__iregex {
7761        local_var_req_builder = match "multi" {
7762            "multi" => local_var_req_builder.query(
7763                &local_var_str
7764                    .into_iter()
7765                    .map(|p| ("title__iregex".to_owned(), p.to_string()))
7766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7767            ),
7768            _ => local_var_req_builder.query(&[(
7769                "title__iregex",
7770                &local_var_str
7771                    .into_iter()
7772                    .map(|p| p.to_string())
7773                    .collect::<Vec<String>>()
7774                    .join(",")
7775                    .to_string(),
7776            )]),
7777        };
7778    }
7779    if let Some(ref local_var_str) = title__isw {
7780        local_var_req_builder = match "multi" {
7781            "multi" => local_var_req_builder.query(
7782                &local_var_str
7783                    .into_iter()
7784                    .map(|p| ("title__isw".to_owned(), p.to_string()))
7785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7786            ),
7787            _ => local_var_req_builder.query(&[(
7788                "title__isw",
7789                &local_var_str
7790                    .into_iter()
7791                    .map(|p| p.to_string())
7792                    .collect::<Vec<String>>()
7793                    .join(",")
7794                    .to_string(),
7795            )]),
7796        };
7797    }
7798    if let Some(ref local_var_str) = title__n {
7799        local_var_req_builder = match "multi" {
7800            "multi" => local_var_req_builder.query(
7801                &local_var_str
7802                    .into_iter()
7803                    .map(|p| ("title__n".to_owned(), p.to_string()))
7804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7805            ),
7806            _ => local_var_req_builder.query(&[(
7807                "title__n",
7808                &local_var_str
7809                    .into_iter()
7810                    .map(|p| p.to_string())
7811                    .collect::<Vec<String>>()
7812                    .join(",")
7813                    .to_string(),
7814            )]),
7815        };
7816    }
7817    if let Some(ref local_var_str) = title__nic {
7818        local_var_req_builder = match "multi" {
7819            "multi" => local_var_req_builder.query(
7820                &local_var_str
7821                    .into_iter()
7822                    .map(|p| ("title__nic".to_owned(), p.to_string()))
7823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7824            ),
7825            _ => local_var_req_builder.query(&[(
7826                "title__nic",
7827                &local_var_str
7828                    .into_iter()
7829                    .map(|p| p.to_string())
7830                    .collect::<Vec<String>>()
7831                    .join(",")
7832                    .to_string(),
7833            )]),
7834        };
7835    }
7836    if let Some(ref local_var_str) = title__nie {
7837        local_var_req_builder = match "multi" {
7838            "multi" => local_var_req_builder.query(
7839                &local_var_str
7840                    .into_iter()
7841                    .map(|p| ("title__nie".to_owned(), p.to_string()))
7842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7843            ),
7844            _ => local_var_req_builder.query(&[(
7845                "title__nie",
7846                &local_var_str
7847                    .into_iter()
7848                    .map(|p| p.to_string())
7849                    .collect::<Vec<String>>()
7850                    .join(",")
7851                    .to_string(),
7852            )]),
7853        };
7854    }
7855    if let Some(ref local_var_str) = title__niew {
7856        local_var_req_builder = match "multi" {
7857            "multi" => local_var_req_builder.query(
7858                &local_var_str
7859                    .into_iter()
7860                    .map(|p| ("title__niew".to_owned(), p.to_string()))
7861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7862            ),
7863            _ => local_var_req_builder.query(&[(
7864                "title__niew",
7865                &local_var_str
7866                    .into_iter()
7867                    .map(|p| p.to_string())
7868                    .collect::<Vec<String>>()
7869                    .join(",")
7870                    .to_string(),
7871            )]),
7872        };
7873    }
7874    if let Some(ref local_var_str) = title__nisw {
7875        local_var_req_builder = match "multi" {
7876            "multi" => local_var_req_builder.query(
7877                &local_var_str
7878                    .into_iter()
7879                    .map(|p| ("title__nisw".to_owned(), p.to_string()))
7880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7881            ),
7882            _ => local_var_req_builder.query(&[(
7883                "title__nisw",
7884                &local_var_str
7885                    .into_iter()
7886                    .map(|p| p.to_string())
7887                    .collect::<Vec<String>>()
7888                    .join(",")
7889                    .to_string(),
7890            )]),
7891        };
7892    }
7893    if let Some(ref local_var_str) = title__regex {
7894        local_var_req_builder = match "multi" {
7895            "multi" => local_var_req_builder.query(
7896                &local_var_str
7897                    .into_iter()
7898                    .map(|p| ("title__regex".to_owned(), p.to_string()))
7899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7900            ),
7901            _ => local_var_req_builder.query(&[(
7902                "title__regex",
7903                &local_var_str
7904                    .into_iter()
7905                    .map(|p| p.to_string())
7906                    .collect::<Vec<String>>()
7907                    .join(",")
7908                    .to_string(),
7909            )]),
7910        };
7911    }
7912    if let Some(ref local_var_str) = updated_by_request {
7913        local_var_req_builder =
7914            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
7915    }
7916    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7917        local_var_req_builder =
7918            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7919    }
7920    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7921        let local_var_key = local_var_apikey.key.clone();
7922        let local_var_value = match local_var_apikey.prefix {
7923            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7924            None => local_var_key,
7925        };
7926        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7927    };
7928
7929    let local_var_req = local_var_req_builder.build()?;
7930    let local_var_resp = local_var_client.execute(local_var_req).await?;
7931
7932    let local_var_status = local_var_resp.status();
7933    let local_var_content = local_var_resp.text().await?;
7934
7935    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7936        serde_json::from_str(&local_var_content).map_err(Error::from)
7937    } else {
7938        let local_var_entity: Option<TenancyContactsListError> =
7939            serde_json::from_str(&local_var_content).ok();
7940        let local_var_error = ResponseContent {
7941            status: local_var_status,
7942            content: local_var_content,
7943            entity: local_var_entity,
7944        };
7945        Err(Error::ResponseError(local_var_error))
7946    }
7947}
7948
7949/// Patch a contact object.
7950pub async fn tenancy_contacts_partial_update(
7951    configuration: &configuration::Configuration,
7952    id: i32,
7953    patched_contact_request: Option<crate::models::PatchedContactRequest>,
7954) -> Result<crate::models::Contact, Error<TenancyContactsPartialUpdateError>> {
7955    let local_var_configuration = configuration;
7956
7957    let local_var_client = &local_var_configuration.client;
7958
7959    let local_var_uri_str = format!(
7960        "{}/api/tenancy/contacts/{id}/",
7961        local_var_configuration.base_path,
7962        id = id
7963    );
7964    let mut local_var_req_builder =
7965        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7966
7967    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7968        local_var_req_builder =
7969            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7970    }
7971    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7972        let local_var_key = local_var_apikey.key.clone();
7973        let local_var_value = match local_var_apikey.prefix {
7974            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7975            None => local_var_key,
7976        };
7977        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7978    };
7979    local_var_req_builder = local_var_req_builder.json(&patched_contact_request);
7980
7981    let local_var_req = local_var_req_builder.build()?;
7982    let local_var_resp = local_var_client.execute(local_var_req).await?;
7983
7984    let local_var_status = local_var_resp.status();
7985    let local_var_content = local_var_resp.text().await?;
7986
7987    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7988        serde_json::from_str(&local_var_content).map_err(Error::from)
7989    } else {
7990        let local_var_entity: Option<TenancyContactsPartialUpdateError> =
7991            serde_json::from_str(&local_var_content).ok();
7992        let local_var_error = ResponseContent {
7993            status: local_var_status,
7994            content: local_var_content,
7995            entity: local_var_entity,
7996        };
7997        Err(Error::ResponseError(local_var_error))
7998    }
7999}
8000
8001/// Get a contact object.
8002pub async fn tenancy_contacts_retrieve(
8003    configuration: &configuration::Configuration,
8004    id: i32,
8005) -> Result<crate::models::Contact, Error<TenancyContactsRetrieveError>> {
8006    let local_var_configuration = configuration;
8007
8008    let local_var_client = &local_var_configuration.client;
8009
8010    let local_var_uri_str = format!(
8011        "{}/api/tenancy/contacts/{id}/",
8012        local_var_configuration.base_path,
8013        id = id
8014    );
8015    let mut local_var_req_builder =
8016        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8017
8018    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8019        local_var_req_builder =
8020            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8021    }
8022    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8023        let local_var_key = local_var_apikey.key.clone();
8024        let local_var_value = match local_var_apikey.prefix {
8025            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8026            None => local_var_key,
8027        };
8028        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8029    };
8030
8031    let local_var_req = local_var_req_builder.build()?;
8032    let local_var_resp = local_var_client.execute(local_var_req).await?;
8033
8034    let local_var_status = local_var_resp.status();
8035    let local_var_content = local_var_resp.text().await?;
8036
8037    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8038        serde_json::from_str(&local_var_content).map_err(Error::from)
8039    } else {
8040        let local_var_entity: Option<TenancyContactsRetrieveError> =
8041            serde_json::from_str(&local_var_content).ok();
8042        let local_var_error = ResponseContent {
8043            status: local_var_status,
8044            content: local_var_content,
8045            entity: local_var_entity,
8046        };
8047        Err(Error::ResponseError(local_var_error))
8048    }
8049}
8050
8051/// Put a contact object.
8052pub async fn tenancy_contacts_update(
8053    configuration: &configuration::Configuration,
8054    id: i32,
8055    contact_request: crate::models::ContactRequest,
8056) -> Result<crate::models::Contact, Error<TenancyContactsUpdateError>> {
8057    let local_var_configuration = configuration;
8058
8059    let local_var_client = &local_var_configuration.client;
8060
8061    let local_var_uri_str = format!(
8062        "{}/api/tenancy/contacts/{id}/",
8063        local_var_configuration.base_path,
8064        id = id
8065    );
8066    let mut local_var_req_builder =
8067        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8068
8069    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8070        local_var_req_builder =
8071            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8072    }
8073    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8074        let local_var_key = local_var_apikey.key.clone();
8075        let local_var_value = match local_var_apikey.prefix {
8076            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8077            None => local_var_key,
8078        };
8079        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8080    };
8081    local_var_req_builder = local_var_req_builder.json(&contact_request);
8082
8083    let local_var_req = local_var_req_builder.build()?;
8084    let local_var_resp = local_var_client.execute(local_var_req).await?;
8085
8086    let local_var_status = local_var_resp.status();
8087    let local_var_content = local_var_resp.text().await?;
8088
8089    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8090        serde_json::from_str(&local_var_content).map_err(Error::from)
8091    } else {
8092        let local_var_entity: Option<TenancyContactsUpdateError> =
8093            serde_json::from_str(&local_var_content).ok();
8094        let local_var_error = ResponseContent {
8095            status: local_var_status,
8096            content: local_var_content,
8097            entity: local_var_entity,
8098        };
8099        Err(Error::ResponseError(local_var_error))
8100    }
8101}
8102
8103/// Delete a list of tenant group objects.
8104pub async fn tenancy_tenant_groups_bulk_destroy(
8105    configuration: &configuration::Configuration,
8106    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8107) -> Result<(), Error<TenancyTenantGroupsBulkDestroyError>> {
8108    let local_var_configuration = configuration;
8109
8110    let local_var_client = &local_var_configuration.client;
8111
8112    let local_var_uri_str = format!(
8113        "{}/api/tenancy/tenant-groups/",
8114        local_var_configuration.base_path
8115    );
8116    let mut local_var_req_builder =
8117        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8118
8119    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8120        local_var_req_builder =
8121            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8122    }
8123    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8124        let local_var_key = local_var_apikey.key.clone();
8125        let local_var_value = match local_var_apikey.prefix {
8126            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8127            None => local_var_key,
8128        };
8129        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8130    };
8131    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8132
8133    let local_var_req = local_var_req_builder.build()?;
8134    let local_var_resp = local_var_client.execute(local_var_req).await?;
8135
8136    let local_var_status = local_var_resp.status();
8137    let local_var_content = local_var_resp.text().await?;
8138
8139    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8140        Ok(())
8141    } else {
8142        let local_var_entity: Option<TenancyTenantGroupsBulkDestroyError> =
8143            serde_json::from_str(&local_var_content).ok();
8144        let local_var_error = ResponseContent {
8145            status: local_var_status,
8146            content: local_var_content,
8147            entity: local_var_entity,
8148        };
8149        Err(Error::ResponseError(local_var_error))
8150    }
8151}
8152
8153/// Patch a list of tenant group objects.
8154pub async fn tenancy_tenant_groups_bulk_partial_update(
8155    configuration: &configuration::Configuration,
8156    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8157) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkPartialUpdateError>> {
8158    let local_var_configuration = configuration;
8159
8160    let local_var_client = &local_var_configuration.client;
8161
8162    let local_var_uri_str = format!(
8163        "{}/api/tenancy/tenant-groups/",
8164        local_var_configuration.base_path
8165    );
8166    let mut local_var_req_builder =
8167        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8168
8169    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8170        local_var_req_builder =
8171            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8172    }
8173    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8174        let local_var_key = local_var_apikey.key.clone();
8175        let local_var_value = match local_var_apikey.prefix {
8176            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8177            None => local_var_key,
8178        };
8179        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8180    };
8181    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8182
8183    let local_var_req = local_var_req_builder.build()?;
8184    let local_var_resp = local_var_client.execute(local_var_req).await?;
8185
8186    let local_var_status = local_var_resp.status();
8187    let local_var_content = local_var_resp.text().await?;
8188
8189    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8190        serde_json::from_str(&local_var_content).map_err(Error::from)
8191    } else {
8192        let local_var_entity: Option<TenancyTenantGroupsBulkPartialUpdateError> =
8193            serde_json::from_str(&local_var_content).ok();
8194        let local_var_error = ResponseContent {
8195            status: local_var_status,
8196            content: local_var_content,
8197            entity: local_var_entity,
8198        };
8199        Err(Error::ResponseError(local_var_error))
8200    }
8201}
8202
8203/// Put a list of tenant group objects.
8204pub async fn tenancy_tenant_groups_bulk_update(
8205    configuration: &configuration::Configuration,
8206    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8207) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkUpdateError>> {
8208    let local_var_configuration = configuration;
8209
8210    let local_var_client = &local_var_configuration.client;
8211
8212    let local_var_uri_str = format!(
8213        "{}/api/tenancy/tenant-groups/",
8214        local_var_configuration.base_path
8215    );
8216    let mut local_var_req_builder =
8217        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8218
8219    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8220        local_var_req_builder =
8221            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8222    }
8223    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8224        let local_var_key = local_var_apikey.key.clone();
8225        let local_var_value = match local_var_apikey.prefix {
8226            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8227            None => local_var_key,
8228        };
8229        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8230    };
8231    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8232
8233    let local_var_req = local_var_req_builder.build()?;
8234    let local_var_resp = local_var_client.execute(local_var_req).await?;
8235
8236    let local_var_status = local_var_resp.status();
8237    let local_var_content = local_var_resp.text().await?;
8238
8239    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8240        serde_json::from_str(&local_var_content).map_err(Error::from)
8241    } else {
8242        let local_var_entity: Option<TenancyTenantGroupsBulkUpdateError> =
8243            serde_json::from_str(&local_var_content).ok();
8244        let local_var_error = ResponseContent {
8245            status: local_var_status,
8246            content: local_var_content,
8247            entity: local_var_entity,
8248        };
8249        Err(Error::ResponseError(local_var_error))
8250    }
8251}
8252
8253/// Post a list of tenant group objects.
8254pub async fn tenancy_tenant_groups_create(
8255    configuration: &configuration::Configuration,
8256    writable_tenant_group_request: crate::models::WritableTenantGroupRequest,
8257) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsCreateError>> {
8258    let local_var_configuration = configuration;
8259
8260    let local_var_client = &local_var_configuration.client;
8261
8262    let local_var_uri_str = format!(
8263        "{}/api/tenancy/tenant-groups/",
8264        local_var_configuration.base_path
8265    );
8266    let mut local_var_req_builder =
8267        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8268
8269    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8270        local_var_req_builder =
8271            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8272    }
8273    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8274        let local_var_key = local_var_apikey.key.clone();
8275        let local_var_value = match local_var_apikey.prefix {
8276            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8277            None => local_var_key,
8278        };
8279        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8280    };
8281    local_var_req_builder = local_var_req_builder.json(&writable_tenant_group_request);
8282
8283    let local_var_req = local_var_req_builder.build()?;
8284    let local_var_resp = local_var_client.execute(local_var_req).await?;
8285
8286    let local_var_status = local_var_resp.status();
8287    let local_var_content = local_var_resp.text().await?;
8288
8289    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8290        serde_json::from_str(&local_var_content).map_err(Error::from)
8291    } else {
8292        let local_var_entity: Option<TenancyTenantGroupsCreateError> =
8293            serde_json::from_str(&local_var_content).ok();
8294        let local_var_error = ResponseContent {
8295            status: local_var_status,
8296            content: local_var_content,
8297            entity: local_var_entity,
8298        };
8299        Err(Error::ResponseError(local_var_error))
8300    }
8301}
8302
8303/// Delete a tenant group object.
8304pub async fn tenancy_tenant_groups_destroy(
8305    configuration: &configuration::Configuration,
8306    id: i32,
8307) -> Result<(), Error<TenancyTenantGroupsDestroyError>> {
8308    let local_var_configuration = configuration;
8309
8310    let local_var_client = &local_var_configuration.client;
8311
8312    let local_var_uri_str = format!(
8313        "{}/api/tenancy/tenant-groups/{id}/",
8314        local_var_configuration.base_path,
8315        id = id
8316    );
8317    let mut local_var_req_builder =
8318        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8319
8320    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8321        local_var_req_builder =
8322            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8323    }
8324    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8325        let local_var_key = local_var_apikey.key.clone();
8326        let local_var_value = match local_var_apikey.prefix {
8327            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8328            None => local_var_key,
8329        };
8330        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8331    };
8332
8333    let local_var_req = local_var_req_builder.build()?;
8334    let local_var_resp = local_var_client.execute(local_var_req).await?;
8335
8336    let local_var_status = local_var_resp.status();
8337    let local_var_content = local_var_resp.text().await?;
8338
8339    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8340        Ok(())
8341    } else {
8342        let local_var_entity: Option<TenancyTenantGroupsDestroyError> =
8343            serde_json::from_str(&local_var_content).ok();
8344        let local_var_error = ResponseContent {
8345            status: local_var_status,
8346            content: local_var_content,
8347            entity: local_var_entity,
8348        };
8349        Err(Error::ResponseError(local_var_error))
8350    }
8351}
8352
8353/// Get a list of tenant group objects.
8354pub async fn tenancy_tenant_groups_list(
8355    configuration: &configuration::Configuration,
8356    ancestor: Option<Vec<String>>,
8357    ancestor__n: Option<Vec<String>>,
8358    ancestor_id: Option<Vec<String>>,
8359    ancestor_id__n: Option<Vec<String>>,
8360    created: Option<Vec<String>>,
8361    created__empty: Option<Vec<String>>,
8362    created__gt: Option<Vec<String>>,
8363    created__gte: Option<Vec<String>>,
8364    created__lt: Option<Vec<String>>,
8365    created__lte: Option<Vec<String>>,
8366    created__n: Option<Vec<String>>,
8367    created_by_request: Option<&str>,
8368    description: Option<Vec<String>>,
8369    description__empty: Option<bool>,
8370    description__ic: Option<Vec<String>>,
8371    description__ie: Option<Vec<String>>,
8372    description__iew: Option<Vec<String>>,
8373    description__iregex: Option<Vec<String>>,
8374    description__isw: Option<Vec<String>>,
8375    description__n: Option<Vec<String>>,
8376    description__nic: Option<Vec<String>>,
8377    description__nie: Option<Vec<String>>,
8378    description__niew: Option<Vec<String>>,
8379    description__nisw: Option<Vec<String>>,
8380    description__regex: Option<Vec<String>>,
8381    id: Option<Vec<i32>>,
8382    id__empty: Option<bool>,
8383    id__gt: Option<Vec<i32>>,
8384    id__gte: Option<Vec<i32>>,
8385    id__lt: Option<Vec<i32>>,
8386    id__lte: Option<Vec<i32>>,
8387    id__n: Option<Vec<i32>>,
8388    last_updated: Option<Vec<String>>,
8389    last_updated__empty: Option<Vec<String>>,
8390    last_updated__gt: Option<Vec<String>>,
8391    last_updated__gte: Option<Vec<String>>,
8392    last_updated__lt: Option<Vec<String>>,
8393    last_updated__lte: Option<Vec<String>>,
8394    last_updated__n: Option<Vec<String>>,
8395    limit: Option<i32>,
8396    modified_by_request: Option<&str>,
8397    name: Option<Vec<String>>,
8398    name__empty: Option<bool>,
8399    name__ic: Option<Vec<String>>,
8400    name__ie: Option<Vec<String>>,
8401    name__iew: Option<Vec<String>>,
8402    name__iregex: Option<Vec<String>>,
8403    name__isw: Option<Vec<String>>,
8404    name__n: Option<Vec<String>>,
8405    name__nic: Option<Vec<String>>,
8406    name__nie: Option<Vec<String>>,
8407    name__niew: Option<Vec<String>>,
8408    name__nisw: Option<Vec<String>>,
8409    name__regex: Option<Vec<String>>,
8410    offset: Option<i32>,
8411    ordering: Option<&str>,
8412    parent: Option<Vec<String>>,
8413    parent__n: Option<Vec<String>>,
8414    parent_id: Option<Vec<i32>>,
8415    parent_id__n: Option<Vec<i32>>,
8416    q: Option<&str>,
8417    slug: Option<Vec<String>>,
8418    slug__empty: Option<bool>,
8419    slug__ic: Option<Vec<String>>,
8420    slug__ie: Option<Vec<String>>,
8421    slug__iew: Option<Vec<String>>,
8422    slug__iregex: Option<Vec<String>>,
8423    slug__isw: Option<Vec<String>>,
8424    slug__n: Option<Vec<String>>,
8425    slug__nic: Option<Vec<String>>,
8426    slug__nie: Option<Vec<String>>,
8427    slug__niew: Option<Vec<String>>,
8428    slug__nisw: Option<Vec<String>>,
8429    slug__regex: Option<Vec<String>>,
8430    tag: Option<Vec<String>>,
8431    tag__n: Option<Vec<String>>,
8432    tag_id: Option<Vec<i32>>,
8433    tag_id__n: Option<Vec<i32>>,
8434    updated_by_request: Option<&str>,
8435) -> Result<crate::models::PaginatedTenantGroupList, Error<TenancyTenantGroupsListError>> {
8436    let local_var_configuration = configuration;
8437
8438    let local_var_client = &local_var_configuration.client;
8439
8440    let local_var_uri_str = format!(
8441        "{}/api/tenancy/tenant-groups/",
8442        local_var_configuration.base_path
8443    );
8444    let mut local_var_req_builder =
8445        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8446
8447    if let Some(ref local_var_str) = ancestor {
8448        local_var_req_builder = match "multi" {
8449            "multi" => local_var_req_builder.query(
8450                &local_var_str
8451                    .into_iter()
8452                    .map(|p| ("ancestor".to_owned(), p.to_string()))
8453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8454            ),
8455            _ => local_var_req_builder.query(&[(
8456                "ancestor",
8457                &local_var_str
8458                    .into_iter()
8459                    .map(|p| p.to_string())
8460                    .collect::<Vec<String>>()
8461                    .join(",")
8462                    .to_string(),
8463            )]),
8464        };
8465    }
8466    if let Some(ref local_var_str) = ancestor__n {
8467        local_var_req_builder = match "multi" {
8468            "multi" => local_var_req_builder.query(
8469                &local_var_str
8470                    .into_iter()
8471                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
8472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8473            ),
8474            _ => local_var_req_builder.query(&[(
8475                "ancestor__n",
8476                &local_var_str
8477                    .into_iter()
8478                    .map(|p| p.to_string())
8479                    .collect::<Vec<String>>()
8480                    .join(",")
8481                    .to_string(),
8482            )]),
8483        };
8484    }
8485    if let Some(ref local_var_str) = ancestor_id {
8486        local_var_req_builder = match "multi" {
8487            "multi" => local_var_req_builder.query(
8488                &local_var_str
8489                    .into_iter()
8490                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
8491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8492            ),
8493            _ => local_var_req_builder.query(&[(
8494                "ancestor_id",
8495                &local_var_str
8496                    .into_iter()
8497                    .map(|p| p.to_string())
8498                    .collect::<Vec<String>>()
8499                    .join(",")
8500                    .to_string(),
8501            )]),
8502        };
8503    }
8504    if let Some(ref local_var_str) = ancestor_id__n {
8505        local_var_req_builder = match "multi" {
8506            "multi" => local_var_req_builder.query(
8507                &local_var_str
8508                    .into_iter()
8509                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
8510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8511            ),
8512            _ => local_var_req_builder.query(&[(
8513                "ancestor_id__n",
8514                &local_var_str
8515                    .into_iter()
8516                    .map(|p| p.to_string())
8517                    .collect::<Vec<String>>()
8518                    .join(",")
8519                    .to_string(),
8520            )]),
8521        };
8522    }
8523    if let Some(ref local_var_str) = created {
8524        local_var_req_builder = match "multi" {
8525            "multi" => local_var_req_builder.query(
8526                &local_var_str
8527                    .into_iter()
8528                    .map(|p| ("created".to_owned(), p.to_string()))
8529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8530            ),
8531            _ => local_var_req_builder.query(&[(
8532                "created",
8533                &local_var_str
8534                    .into_iter()
8535                    .map(|p| p.to_string())
8536                    .collect::<Vec<String>>()
8537                    .join(",")
8538                    .to_string(),
8539            )]),
8540        };
8541    }
8542    if let Some(ref local_var_str) = created__empty {
8543        local_var_req_builder = match "multi" {
8544            "multi" => local_var_req_builder.query(
8545                &local_var_str
8546                    .into_iter()
8547                    .map(|p| ("created__empty".to_owned(), p.to_string()))
8548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8549            ),
8550            _ => local_var_req_builder.query(&[(
8551                "created__empty",
8552                &local_var_str
8553                    .into_iter()
8554                    .map(|p| p.to_string())
8555                    .collect::<Vec<String>>()
8556                    .join(",")
8557                    .to_string(),
8558            )]),
8559        };
8560    }
8561    if let Some(ref local_var_str) = created__gt {
8562        local_var_req_builder = match "multi" {
8563            "multi" => local_var_req_builder.query(
8564                &local_var_str
8565                    .into_iter()
8566                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8568            ),
8569            _ => local_var_req_builder.query(&[(
8570                "created__gt",
8571                &local_var_str
8572                    .into_iter()
8573                    .map(|p| p.to_string())
8574                    .collect::<Vec<String>>()
8575                    .join(",")
8576                    .to_string(),
8577            )]),
8578        };
8579    }
8580    if let Some(ref local_var_str) = created__gte {
8581        local_var_req_builder = match "multi" {
8582            "multi" => local_var_req_builder.query(
8583                &local_var_str
8584                    .into_iter()
8585                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8587            ),
8588            _ => local_var_req_builder.query(&[(
8589                "created__gte",
8590                &local_var_str
8591                    .into_iter()
8592                    .map(|p| p.to_string())
8593                    .collect::<Vec<String>>()
8594                    .join(",")
8595                    .to_string(),
8596            )]),
8597        };
8598    }
8599    if let Some(ref local_var_str) = created__lt {
8600        local_var_req_builder = match "multi" {
8601            "multi" => local_var_req_builder.query(
8602                &local_var_str
8603                    .into_iter()
8604                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8606            ),
8607            _ => local_var_req_builder.query(&[(
8608                "created__lt",
8609                &local_var_str
8610                    .into_iter()
8611                    .map(|p| p.to_string())
8612                    .collect::<Vec<String>>()
8613                    .join(",")
8614                    .to_string(),
8615            )]),
8616        };
8617    }
8618    if let Some(ref local_var_str) = created__lte {
8619        local_var_req_builder = match "multi" {
8620            "multi" => local_var_req_builder.query(
8621                &local_var_str
8622                    .into_iter()
8623                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8625            ),
8626            _ => local_var_req_builder.query(&[(
8627                "created__lte",
8628                &local_var_str
8629                    .into_iter()
8630                    .map(|p| p.to_string())
8631                    .collect::<Vec<String>>()
8632                    .join(",")
8633                    .to_string(),
8634            )]),
8635        };
8636    }
8637    if let Some(ref local_var_str) = created__n {
8638        local_var_req_builder = match "multi" {
8639            "multi" => local_var_req_builder.query(
8640                &local_var_str
8641                    .into_iter()
8642                    .map(|p| ("created__n".to_owned(), p.to_string()))
8643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8644            ),
8645            _ => local_var_req_builder.query(&[(
8646                "created__n",
8647                &local_var_str
8648                    .into_iter()
8649                    .map(|p| p.to_string())
8650                    .collect::<Vec<String>>()
8651                    .join(",")
8652                    .to_string(),
8653            )]),
8654        };
8655    }
8656    if let Some(ref local_var_str) = created_by_request {
8657        local_var_req_builder =
8658            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
8659    }
8660    if let Some(ref local_var_str) = description {
8661        local_var_req_builder = match "multi" {
8662            "multi" => local_var_req_builder.query(
8663                &local_var_str
8664                    .into_iter()
8665                    .map(|p| ("description".to_owned(), p.to_string()))
8666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8667            ),
8668            _ => local_var_req_builder.query(&[(
8669                "description",
8670                &local_var_str
8671                    .into_iter()
8672                    .map(|p| p.to_string())
8673                    .collect::<Vec<String>>()
8674                    .join(",")
8675                    .to_string(),
8676            )]),
8677        };
8678    }
8679    if let Some(ref local_var_str) = description__empty {
8680        local_var_req_builder =
8681            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
8682    }
8683    if let Some(ref local_var_str) = description__ic {
8684        local_var_req_builder = match "multi" {
8685            "multi" => local_var_req_builder.query(
8686                &local_var_str
8687                    .into_iter()
8688                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8690            ),
8691            _ => local_var_req_builder.query(&[(
8692                "description__ic",
8693                &local_var_str
8694                    .into_iter()
8695                    .map(|p| p.to_string())
8696                    .collect::<Vec<String>>()
8697                    .join(",")
8698                    .to_string(),
8699            )]),
8700        };
8701    }
8702    if let Some(ref local_var_str) = description__ie {
8703        local_var_req_builder = match "multi" {
8704            "multi" => local_var_req_builder.query(
8705                &local_var_str
8706                    .into_iter()
8707                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8709            ),
8710            _ => local_var_req_builder.query(&[(
8711                "description__ie",
8712                &local_var_str
8713                    .into_iter()
8714                    .map(|p| p.to_string())
8715                    .collect::<Vec<String>>()
8716                    .join(",")
8717                    .to_string(),
8718            )]),
8719        };
8720    }
8721    if let Some(ref local_var_str) = description__iew {
8722        local_var_req_builder = match "multi" {
8723            "multi" => local_var_req_builder.query(
8724                &local_var_str
8725                    .into_iter()
8726                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8728            ),
8729            _ => local_var_req_builder.query(&[(
8730                "description__iew",
8731                &local_var_str
8732                    .into_iter()
8733                    .map(|p| p.to_string())
8734                    .collect::<Vec<String>>()
8735                    .join(",")
8736                    .to_string(),
8737            )]),
8738        };
8739    }
8740    if let Some(ref local_var_str) = description__iregex {
8741        local_var_req_builder = match "multi" {
8742            "multi" => local_var_req_builder.query(
8743                &local_var_str
8744                    .into_iter()
8745                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
8746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8747            ),
8748            _ => local_var_req_builder.query(&[(
8749                "description__iregex",
8750                &local_var_str
8751                    .into_iter()
8752                    .map(|p| p.to_string())
8753                    .collect::<Vec<String>>()
8754                    .join(",")
8755                    .to_string(),
8756            )]),
8757        };
8758    }
8759    if let Some(ref local_var_str) = description__isw {
8760        local_var_req_builder = match "multi" {
8761            "multi" => local_var_req_builder.query(
8762                &local_var_str
8763                    .into_iter()
8764                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8766            ),
8767            _ => local_var_req_builder.query(&[(
8768                "description__isw",
8769                &local_var_str
8770                    .into_iter()
8771                    .map(|p| p.to_string())
8772                    .collect::<Vec<String>>()
8773                    .join(",")
8774                    .to_string(),
8775            )]),
8776        };
8777    }
8778    if let Some(ref local_var_str) = description__n {
8779        local_var_req_builder = match "multi" {
8780            "multi" => local_var_req_builder.query(
8781                &local_var_str
8782                    .into_iter()
8783                    .map(|p| ("description__n".to_owned(), p.to_string()))
8784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8785            ),
8786            _ => local_var_req_builder.query(&[(
8787                "description__n",
8788                &local_var_str
8789                    .into_iter()
8790                    .map(|p| p.to_string())
8791                    .collect::<Vec<String>>()
8792                    .join(",")
8793                    .to_string(),
8794            )]),
8795        };
8796    }
8797    if let Some(ref local_var_str) = description__nic {
8798        local_var_req_builder = match "multi" {
8799            "multi" => local_var_req_builder.query(
8800                &local_var_str
8801                    .into_iter()
8802                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8804            ),
8805            _ => local_var_req_builder.query(&[(
8806                "description__nic",
8807                &local_var_str
8808                    .into_iter()
8809                    .map(|p| p.to_string())
8810                    .collect::<Vec<String>>()
8811                    .join(",")
8812                    .to_string(),
8813            )]),
8814        };
8815    }
8816    if let Some(ref local_var_str) = description__nie {
8817        local_var_req_builder = match "multi" {
8818            "multi" => local_var_req_builder.query(
8819                &local_var_str
8820                    .into_iter()
8821                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8823            ),
8824            _ => local_var_req_builder.query(&[(
8825                "description__nie",
8826                &local_var_str
8827                    .into_iter()
8828                    .map(|p| p.to_string())
8829                    .collect::<Vec<String>>()
8830                    .join(",")
8831                    .to_string(),
8832            )]),
8833        };
8834    }
8835    if let Some(ref local_var_str) = description__niew {
8836        local_var_req_builder = match "multi" {
8837            "multi" => local_var_req_builder.query(
8838                &local_var_str
8839                    .into_iter()
8840                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8842            ),
8843            _ => local_var_req_builder.query(&[(
8844                "description__niew",
8845                &local_var_str
8846                    .into_iter()
8847                    .map(|p| p.to_string())
8848                    .collect::<Vec<String>>()
8849                    .join(",")
8850                    .to_string(),
8851            )]),
8852        };
8853    }
8854    if let Some(ref local_var_str) = description__nisw {
8855        local_var_req_builder = match "multi" {
8856            "multi" => local_var_req_builder.query(
8857                &local_var_str
8858                    .into_iter()
8859                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8861            ),
8862            _ => local_var_req_builder.query(&[(
8863                "description__nisw",
8864                &local_var_str
8865                    .into_iter()
8866                    .map(|p| p.to_string())
8867                    .collect::<Vec<String>>()
8868                    .join(",")
8869                    .to_string(),
8870            )]),
8871        };
8872    }
8873    if let Some(ref local_var_str) = description__regex {
8874        local_var_req_builder = match "multi" {
8875            "multi" => local_var_req_builder.query(
8876                &local_var_str
8877                    .into_iter()
8878                    .map(|p| ("description__regex".to_owned(), p.to_string()))
8879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8880            ),
8881            _ => local_var_req_builder.query(&[(
8882                "description__regex",
8883                &local_var_str
8884                    .into_iter()
8885                    .map(|p| p.to_string())
8886                    .collect::<Vec<String>>()
8887                    .join(",")
8888                    .to_string(),
8889            )]),
8890        };
8891    }
8892    if let Some(ref local_var_str) = id {
8893        local_var_req_builder = match "multi" {
8894            "multi" => local_var_req_builder.query(
8895                &local_var_str
8896                    .into_iter()
8897                    .map(|p| ("id".to_owned(), p.to_string()))
8898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8899            ),
8900            _ => local_var_req_builder.query(&[(
8901                "id",
8902                &local_var_str
8903                    .into_iter()
8904                    .map(|p| p.to_string())
8905                    .collect::<Vec<String>>()
8906                    .join(",")
8907                    .to_string(),
8908            )]),
8909        };
8910    }
8911    if let Some(ref local_var_str) = id__empty {
8912        local_var_req_builder =
8913            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8914    }
8915    if let Some(ref local_var_str) = id__gt {
8916        local_var_req_builder = match "multi" {
8917            "multi" => local_var_req_builder.query(
8918                &local_var_str
8919                    .into_iter()
8920                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8922            ),
8923            _ => local_var_req_builder.query(&[(
8924                "id__gt",
8925                &local_var_str
8926                    .into_iter()
8927                    .map(|p| p.to_string())
8928                    .collect::<Vec<String>>()
8929                    .join(",")
8930                    .to_string(),
8931            )]),
8932        };
8933    }
8934    if let Some(ref local_var_str) = id__gte {
8935        local_var_req_builder = match "multi" {
8936            "multi" => local_var_req_builder.query(
8937                &local_var_str
8938                    .into_iter()
8939                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8941            ),
8942            _ => local_var_req_builder.query(&[(
8943                "id__gte",
8944                &local_var_str
8945                    .into_iter()
8946                    .map(|p| p.to_string())
8947                    .collect::<Vec<String>>()
8948                    .join(",")
8949                    .to_string(),
8950            )]),
8951        };
8952    }
8953    if let Some(ref local_var_str) = id__lt {
8954        local_var_req_builder = match "multi" {
8955            "multi" => local_var_req_builder.query(
8956                &local_var_str
8957                    .into_iter()
8958                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8960            ),
8961            _ => local_var_req_builder.query(&[(
8962                "id__lt",
8963                &local_var_str
8964                    .into_iter()
8965                    .map(|p| p.to_string())
8966                    .collect::<Vec<String>>()
8967                    .join(",")
8968                    .to_string(),
8969            )]),
8970        };
8971    }
8972    if let Some(ref local_var_str) = id__lte {
8973        local_var_req_builder = match "multi" {
8974            "multi" => local_var_req_builder.query(
8975                &local_var_str
8976                    .into_iter()
8977                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8979            ),
8980            _ => local_var_req_builder.query(&[(
8981                "id__lte",
8982                &local_var_str
8983                    .into_iter()
8984                    .map(|p| p.to_string())
8985                    .collect::<Vec<String>>()
8986                    .join(",")
8987                    .to_string(),
8988            )]),
8989        };
8990    }
8991    if let Some(ref local_var_str) = id__n {
8992        local_var_req_builder = match "multi" {
8993            "multi" => local_var_req_builder.query(
8994                &local_var_str
8995                    .into_iter()
8996                    .map(|p| ("id__n".to_owned(), p.to_string()))
8997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8998            ),
8999            _ => local_var_req_builder.query(&[(
9000                "id__n",
9001                &local_var_str
9002                    .into_iter()
9003                    .map(|p| p.to_string())
9004                    .collect::<Vec<String>>()
9005                    .join(",")
9006                    .to_string(),
9007            )]),
9008        };
9009    }
9010    if let Some(ref local_var_str) = last_updated {
9011        local_var_req_builder = match "multi" {
9012            "multi" => local_var_req_builder.query(
9013                &local_var_str
9014                    .into_iter()
9015                    .map(|p| ("last_updated".to_owned(), p.to_string()))
9016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9017            ),
9018            _ => local_var_req_builder.query(&[(
9019                "last_updated",
9020                &local_var_str
9021                    .into_iter()
9022                    .map(|p| p.to_string())
9023                    .collect::<Vec<String>>()
9024                    .join(",")
9025                    .to_string(),
9026            )]),
9027        };
9028    }
9029    if let Some(ref local_var_str) = last_updated__empty {
9030        local_var_req_builder = match "multi" {
9031            "multi" => local_var_req_builder.query(
9032                &local_var_str
9033                    .into_iter()
9034                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
9035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9036            ),
9037            _ => local_var_req_builder.query(&[(
9038                "last_updated__empty",
9039                &local_var_str
9040                    .into_iter()
9041                    .map(|p| p.to_string())
9042                    .collect::<Vec<String>>()
9043                    .join(",")
9044                    .to_string(),
9045            )]),
9046        };
9047    }
9048    if let Some(ref local_var_str) = last_updated__gt {
9049        local_var_req_builder = match "multi" {
9050            "multi" => local_var_req_builder.query(
9051                &local_var_str
9052                    .into_iter()
9053                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
9054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9055            ),
9056            _ => local_var_req_builder.query(&[(
9057                "last_updated__gt",
9058                &local_var_str
9059                    .into_iter()
9060                    .map(|p| p.to_string())
9061                    .collect::<Vec<String>>()
9062                    .join(",")
9063                    .to_string(),
9064            )]),
9065        };
9066    }
9067    if let Some(ref local_var_str) = last_updated__gte {
9068        local_var_req_builder = match "multi" {
9069            "multi" => local_var_req_builder.query(
9070                &local_var_str
9071                    .into_iter()
9072                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
9073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9074            ),
9075            _ => local_var_req_builder.query(&[(
9076                "last_updated__gte",
9077                &local_var_str
9078                    .into_iter()
9079                    .map(|p| p.to_string())
9080                    .collect::<Vec<String>>()
9081                    .join(",")
9082                    .to_string(),
9083            )]),
9084        };
9085    }
9086    if let Some(ref local_var_str) = last_updated__lt {
9087        local_var_req_builder = match "multi" {
9088            "multi" => local_var_req_builder.query(
9089                &local_var_str
9090                    .into_iter()
9091                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
9092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9093            ),
9094            _ => local_var_req_builder.query(&[(
9095                "last_updated__lt",
9096                &local_var_str
9097                    .into_iter()
9098                    .map(|p| p.to_string())
9099                    .collect::<Vec<String>>()
9100                    .join(",")
9101                    .to_string(),
9102            )]),
9103        };
9104    }
9105    if let Some(ref local_var_str) = last_updated__lte {
9106        local_var_req_builder = match "multi" {
9107            "multi" => local_var_req_builder.query(
9108                &local_var_str
9109                    .into_iter()
9110                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
9111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9112            ),
9113            _ => local_var_req_builder.query(&[(
9114                "last_updated__lte",
9115                &local_var_str
9116                    .into_iter()
9117                    .map(|p| p.to_string())
9118                    .collect::<Vec<String>>()
9119                    .join(",")
9120                    .to_string(),
9121            )]),
9122        };
9123    }
9124    if let Some(ref local_var_str) = last_updated__n {
9125        local_var_req_builder = match "multi" {
9126            "multi" => local_var_req_builder.query(
9127                &local_var_str
9128                    .into_iter()
9129                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
9130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9131            ),
9132            _ => local_var_req_builder.query(&[(
9133                "last_updated__n",
9134                &local_var_str
9135                    .into_iter()
9136                    .map(|p| p.to_string())
9137                    .collect::<Vec<String>>()
9138                    .join(",")
9139                    .to_string(),
9140            )]),
9141        };
9142    }
9143    if let Some(ref local_var_str) = limit {
9144        local_var_req_builder =
9145            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9146    }
9147    if let Some(ref local_var_str) = modified_by_request {
9148        local_var_req_builder =
9149            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
9150    }
9151    if let Some(ref local_var_str) = name {
9152        local_var_req_builder = match "multi" {
9153            "multi" => local_var_req_builder.query(
9154                &local_var_str
9155                    .into_iter()
9156                    .map(|p| ("name".to_owned(), p.to_string()))
9157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9158            ),
9159            _ => local_var_req_builder.query(&[(
9160                "name",
9161                &local_var_str
9162                    .into_iter()
9163                    .map(|p| p.to_string())
9164                    .collect::<Vec<String>>()
9165                    .join(",")
9166                    .to_string(),
9167            )]),
9168        };
9169    }
9170    if let Some(ref local_var_str) = name__empty {
9171        local_var_req_builder =
9172            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
9173    }
9174    if let Some(ref local_var_str) = name__ic {
9175        local_var_req_builder = match "multi" {
9176            "multi" => local_var_req_builder.query(
9177                &local_var_str
9178                    .into_iter()
9179                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9181            ),
9182            _ => local_var_req_builder.query(&[(
9183                "name__ic",
9184                &local_var_str
9185                    .into_iter()
9186                    .map(|p| p.to_string())
9187                    .collect::<Vec<String>>()
9188                    .join(",")
9189                    .to_string(),
9190            )]),
9191        };
9192    }
9193    if let Some(ref local_var_str) = name__ie {
9194        local_var_req_builder = match "multi" {
9195            "multi" => local_var_req_builder.query(
9196                &local_var_str
9197                    .into_iter()
9198                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9200            ),
9201            _ => local_var_req_builder.query(&[(
9202                "name__ie",
9203                &local_var_str
9204                    .into_iter()
9205                    .map(|p| p.to_string())
9206                    .collect::<Vec<String>>()
9207                    .join(",")
9208                    .to_string(),
9209            )]),
9210        };
9211    }
9212    if let Some(ref local_var_str) = name__iew {
9213        local_var_req_builder = match "multi" {
9214            "multi" => local_var_req_builder.query(
9215                &local_var_str
9216                    .into_iter()
9217                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9219            ),
9220            _ => local_var_req_builder.query(&[(
9221                "name__iew",
9222                &local_var_str
9223                    .into_iter()
9224                    .map(|p| p.to_string())
9225                    .collect::<Vec<String>>()
9226                    .join(",")
9227                    .to_string(),
9228            )]),
9229        };
9230    }
9231    if let Some(ref local_var_str) = name__iregex {
9232        local_var_req_builder = match "multi" {
9233            "multi" => local_var_req_builder.query(
9234                &local_var_str
9235                    .into_iter()
9236                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9238            ),
9239            _ => local_var_req_builder.query(&[(
9240                "name__iregex",
9241                &local_var_str
9242                    .into_iter()
9243                    .map(|p| p.to_string())
9244                    .collect::<Vec<String>>()
9245                    .join(",")
9246                    .to_string(),
9247            )]),
9248        };
9249    }
9250    if let Some(ref local_var_str) = name__isw {
9251        local_var_req_builder = match "multi" {
9252            "multi" => local_var_req_builder.query(
9253                &local_var_str
9254                    .into_iter()
9255                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9257            ),
9258            _ => local_var_req_builder.query(&[(
9259                "name__isw",
9260                &local_var_str
9261                    .into_iter()
9262                    .map(|p| p.to_string())
9263                    .collect::<Vec<String>>()
9264                    .join(",")
9265                    .to_string(),
9266            )]),
9267        };
9268    }
9269    if let Some(ref local_var_str) = name__n {
9270        local_var_req_builder = match "multi" {
9271            "multi" => local_var_req_builder.query(
9272                &local_var_str
9273                    .into_iter()
9274                    .map(|p| ("name__n".to_owned(), p.to_string()))
9275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9276            ),
9277            _ => local_var_req_builder.query(&[(
9278                "name__n",
9279                &local_var_str
9280                    .into_iter()
9281                    .map(|p| p.to_string())
9282                    .collect::<Vec<String>>()
9283                    .join(",")
9284                    .to_string(),
9285            )]),
9286        };
9287    }
9288    if let Some(ref local_var_str) = name__nic {
9289        local_var_req_builder = match "multi" {
9290            "multi" => local_var_req_builder.query(
9291                &local_var_str
9292                    .into_iter()
9293                    .map(|p| ("name__nic".to_owned(), p.to_string()))
9294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9295            ),
9296            _ => local_var_req_builder.query(&[(
9297                "name__nic",
9298                &local_var_str
9299                    .into_iter()
9300                    .map(|p| p.to_string())
9301                    .collect::<Vec<String>>()
9302                    .join(",")
9303                    .to_string(),
9304            )]),
9305        };
9306    }
9307    if let Some(ref local_var_str) = name__nie {
9308        local_var_req_builder = match "multi" {
9309            "multi" => local_var_req_builder.query(
9310                &local_var_str
9311                    .into_iter()
9312                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9314            ),
9315            _ => local_var_req_builder.query(&[(
9316                "name__nie",
9317                &local_var_str
9318                    .into_iter()
9319                    .map(|p| p.to_string())
9320                    .collect::<Vec<String>>()
9321                    .join(",")
9322                    .to_string(),
9323            )]),
9324        };
9325    }
9326    if let Some(ref local_var_str) = name__niew {
9327        local_var_req_builder = match "multi" {
9328            "multi" => local_var_req_builder.query(
9329                &local_var_str
9330                    .into_iter()
9331                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9333            ),
9334            _ => local_var_req_builder.query(&[(
9335                "name__niew",
9336                &local_var_str
9337                    .into_iter()
9338                    .map(|p| p.to_string())
9339                    .collect::<Vec<String>>()
9340                    .join(",")
9341                    .to_string(),
9342            )]),
9343        };
9344    }
9345    if let Some(ref local_var_str) = name__nisw {
9346        local_var_req_builder = match "multi" {
9347            "multi" => local_var_req_builder.query(
9348                &local_var_str
9349                    .into_iter()
9350                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9352            ),
9353            _ => local_var_req_builder.query(&[(
9354                "name__nisw",
9355                &local_var_str
9356                    .into_iter()
9357                    .map(|p| p.to_string())
9358                    .collect::<Vec<String>>()
9359                    .join(",")
9360                    .to_string(),
9361            )]),
9362        };
9363    }
9364    if let Some(ref local_var_str) = name__regex {
9365        local_var_req_builder = match "multi" {
9366            "multi" => local_var_req_builder.query(
9367                &local_var_str
9368                    .into_iter()
9369                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9371            ),
9372            _ => local_var_req_builder.query(&[(
9373                "name__regex",
9374                &local_var_str
9375                    .into_iter()
9376                    .map(|p| p.to_string())
9377                    .collect::<Vec<String>>()
9378                    .join(",")
9379                    .to_string(),
9380            )]),
9381        };
9382    }
9383    if let Some(ref local_var_str) = offset {
9384        local_var_req_builder =
9385            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9386    }
9387    if let Some(ref local_var_str) = ordering {
9388        local_var_req_builder =
9389            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9390    }
9391    if let Some(ref local_var_str) = parent {
9392        local_var_req_builder = match "multi" {
9393            "multi" => local_var_req_builder.query(
9394                &local_var_str
9395                    .into_iter()
9396                    .map(|p| ("parent".to_owned(), p.to_string()))
9397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9398            ),
9399            _ => local_var_req_builder.query(&[(
9400                "parent",
9401                &local_var_str
9402                    .into_iter()
9403                    .map(|p| p.to_string())
9404                    .collect::<Vec<String>>()
9405                    .join(",")
9406                    .to_string(),
9407            )]),
9408        };
9409    }
9410    if let Some(ref local_var_str) = parent__n {
9411        local_var_req_builder = match "multi" {
9412            "multi" => local_var_req_builder.query(
9413                &local_var_str
9414                    .into_iter()
9415                    .map(|p| ("parent__n".to_owned(), p.to_string()))
9416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9417            ),
9418            _ => local_var_req_builder.query(&[(
9419                "parent__n",
9420                &local_var_str
9421                    .into_iter()
9422                    .map(|p| p.to_string())
9423                    .collect::<Vec<String>>()
9424                    .join(",")
9425                    .to_string(),
9426            )]),
9427        };
9428    }
9429    if let Some(ref local_var_str) = parent_id {
9430        local_var_req_builder = match "multi" {
9431            "multi" => local_var_req_builder.query(
9432                &local_var_str
9433                    .into_iter()
9434                    .map(|p| ("parent_id".to_owned(), p.to_string()))
9435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9436            ),
9437            _ => local_var_req_builder.query(&[(
9438                "parent_id",
9439                &local_var_str
9440                    .into_iter()
9441                    .map(|p| p.to_string())
9442                    .collect::<Vec<String>>()
9443                    .join(",")
9444                    .to_string(),
9445            )]),
9446        };
9447    }
9448    if let Some(ref local_var_str) = parent_id__n {
9449        local_var_req_builder = match "multi" {
9450            "multi" => local_var_req_builder.query(
9451                &local_var_str
9452                    .into_iter()
9453                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
9454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9455            ),
9456            _ => local_var_req_builder.query(&[(
9457                "parent_id__n",
9458                &local_var_str
9459                    .into_iter()
9460                    .map(|p| p.to_string())
9461                    .collect::<Vec<String>>()
9462                    .join(",")
9463                    .to_string(),
9464            )]),
9465        };
9466    }
9467    if let Some(ref local_var_str) = q {
9468        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9469    }
9470    if let Some(ref local_var_str) = slug {
9471        local_var_req_builder = match "multi" {
9472            "multi" => local_var_req_builder.query(
9473                &local_var_str
9474                    .into_iter()
9475                    .map(|p| ("slug".to_owned(), p.to_string()))
9476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9477            ),
9478            _ => local_var_req_builder.query(&[(
9479                "slug",
9480                &local_var_str
9481                    .into_iter()
9482                    .map(|p| p.to_string())
9483                    .collect::<Vec<String>>()
9484                    .join(",")
9485                    .to_string(),
9486            )]),
9487        };
9488    }
9489    if let Some(ref local_var_str) = slug__empty {
9490        local_var_req_builder =
9491            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
9492    }
9493    if let Some(ref local_var_str) = slug__ic {
9494        local_var_req_builder = match "multi" {
9495            "multi" => local_var_req_builder.query(
9496                &local_var_str
9497                    .into_iter()
9498                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
9499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9500            ),
9501            _ => local_var_req_builder.query(&[(
9502                "slug__ic",
9503                &local_var_str
9504                    .into_iter()
9505                    .map(|p| p.to_string())
9506                    .collect::<Vec<String>>()
9507                    .join(",")
9508                    .to_string(),
9509            )]),
9510        };
9511    }
9512    if let Some(ref local_var_str) = slug__ie {
9513        local_var_req_builder = match "multi" {
9514            "multi" => local_var_req_builder.query(
9515                &local_var_str
9516                    .into_iter()
9517                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
9518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9519            ),
9520            _ => local_var_req_builder.query(&[(
9521                "slug__ie",
9522                &local_var_str
9523                    .into_iter()
9524                    .map(|p| p.to_string())
9525                    .collect::<Vec<String>>()
9526                    .join(",")
9527                    .to_string(),
9528            )]),
9529        };
9530    }
9531    if let Some(ref local_var_str) = slug__iew {
9532        local_var_req_builder = match "multi" {
9533            "multi" => local_var_req_builder.query(
9534                &local_var_str
9535                    .into_iter()
9536                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
9537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9538            ),
9539            _ => local_var_req_builder.query(&[(
9540                "slug__iew",
9541                &local_var_str
9542                    .into_iter()
9543                    .map(|p| p.to_string())
9544                    .collect::<Vec<String>>()
9545                    .join(",")
9546                    .to_string(),
9547            )]),
9548        };
9549    }
9550    if let Some(ref local_var_str) = slug__iregex {
9551        local_var_req_builder = match "multi" {
9552            "multi" => local_var_req_builder.query(
9553                &local_var_str
9554                    .into_iter()
9555                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
9556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9557            ),
9558            _ => local_var_req_builder.query(&[(
9559                "slug__iregex",
9560                &local_var_str
9561                    .into_iter()
9562                    .map(|p| p.to_string())
9563                    .collect::<Vec<String>>()
9564                    .join(",")
9565                    .to_string(),
9566            )]),
9567        };
9568    }
9569    if let Some(ref local_var_str) = slug__isw {
9570        local_var_req_builder = match "multi" {
9571            "multi" => local_var_req_builder.query(
9572                &local_var_str
9573                    .into_iter()
9574                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
9575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9576            ),
9577            _ => local_var_req_builder.query(&[(
9578                "slug__isw",
9579                &local_var_str
9580                    .into_iter()
9581                    .map(|p| p.to_string())
9582                    .collect::<Vec<String>>()
9583                    .join(",")
9584                    .to_string(),
9585            )]),
9586        };
9587    }
9588    if let Some(ref local_var_str) = slug__n {
9589        local_var_req_builder = match "multi" {
9590            "multi" => local_var_req_builder.query(
9591                &local_var_str
9592                    .into_iter()
9593                    .map(|p| ("slug__n".to_owned(), p.to_string()))
9594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9595            ),
9596            _ => local_var_req_builder.query(&[(
9597                "slug__n",
9598                &local_var_str
9599                    .into_iter()
9600                    .map(|p| p.to_string())
9601                    .collect::<Vec<String>>()
9602                    .join(",")
9603                    .to_string(),
9604            )]),
9605        };
9606    }
9607    if let Some(ref local_var_str) = slug__nic {
9608        local_var_req_builder = match "multi" {
9609            "multi" => local_var_req_builder.query(
9610                &local_var_str
9611                    .into_iter()
9612                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
9613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9614            ),
9615            _ => local_var_req_builder.query(&[(
9616                "slug__nic",
9617                &local_var_str
9618                    .into_iter()
9619                    .map(|p| p.to_string())
9620                    .collect::<Vec<String>>()
9621                    .join(",")
9622                    .to_string(),
9623            )]),
9624        };
9625    }
9626    if let Some(ref local_var_str) = slug__nie {
9627        local_var_req_builder = match "multi" {
9628            "multi" => local_var_req_builder.query(
9629                &local_var_str
9630                    .into_iter()
9631                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
9632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9633            ),
9634            _ => local_var_req_builder.query(&[(
9635                "slug__nie",
9636                &local_var_str
9637                    .into_iter()
9638                    .map(|p| p.to_string())
9639                    .collect::<Vec<String>>()
9640                    .join(",")
9641                    .to_string(),
9642            )]),
9643        };
9644    }
9645    if let Some(ref local_var_str) = slug__niew {
9646        local_var_req_builder = match "multi" {
9647            "multi" => local_var_req_builder.query(
9648                &local_var_str
9649                    .into_iter()
9650                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
9651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9652            ),
9653            _ => local_var_req_builder.query(&[(
9654                "slug__niew",
9655                &local_var_str
9656                    .into_iter()
9657                    .map(|p| p.to_string())
9658                    .collect::<Vec<String>>()
9659                    .join(",")
9660                    .to_string(),
9661            )]),
9662        };
9663    }
9664    if let Some(ref local_var_str) = slug__nisw {
9665        local_var_req_builder = match "multi" {
9666            "multi" => local_var_req_builder.query(
9667                &local_var_str
9668                    .into_iter()
9669                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
9670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9671            ),
9672            _ => local_var_req_builder.query(&[(
9673                "slug__nisw",
9674                &local_var_str
9675                    .into_iter()
9676                    .map(|p| p.to_string())
9677                    .collect::<Vec<String>>()
9678                    .join(",")
9679                    .to_string(),
9680            )]),
9681        };
9682    }
9683    if let Some(ref local_var_str) = slug__regex {
9684        local_var_req_builder = match "multi" {
9685            "multi" => local_var_req_builder.query(
9686                &local_var_str
9687                    .into_iter()
9688                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
9689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9690            ),
9691            _ => local_var_req_builder.query(&[(
9692                "slug__regex",
9693                &local_var_str
9694                    .into_iter()
9695                    .map(|p| p.to_string())
9696                    .collect::<Vec<String>>()
9697                    .join(",")
9698                    .to_string(),
9699            )]),
9700        };
9701    }
9702    if let Some(ref local_var_str) = tag {
9703        local_var_req_builder = match "multi" {
9704            "multi" => local_var_req_builder.query(
9705                &local_var_str
9706                    .into_iter()
9707                    .map(|p| ("tag".to_owned(), p.to_string()))
9708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9709            ),
9710            _ => local_var_req_builder.query(&[(
9711                "tag",
9712                &local_var_str
9713                    .into_iter()
9714                    .map(|p| p.to_string())
9715                    .collect::<Vec<String>>()
9716                    .join(",")
9717                    .to_string(),
9718            )]),
9719        };
9720    }
9721    if let Some(ref local_var_str) = tag__n {
9722        local_var_req_builder = match "multi" {
9723            "multi" => local_var_req_builder.query(
9724                &local_var_str
9725                    .into_iter()
9726                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9728            ),
9729            _ => local_var_req_builder.query(&[(
9730                "tag__n",
9731                &local_var_str
9732                    .into_iter()
9733                    .map(|p| p.to_string())
9734                    .collect::<Vec<String>>()
9735                    .join(",")
9736                    .to_string(),
9737            )]),
9738        };
9739    }
9740    if let Some(ref local_var_str) = tag_id {
9741        local_var_req_builder = match "multi" {
9742            "multi" => local_var_req_builder.query(
9743                &local_var_str
9744                    .into_iter()
9745                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9747            ),
9748            _ => local_var_req_builder.query(&[(
9749                "tag_id",
9750                &local_var_str
9751                    .into_iter()
9752                    .map(|p| p.to_string())
9753                    .collect::<Vec<String>>()
9754                    .join(",")
9755                    .to_string(),
9756            )]),
9757        };
9758    }
9759    if let Some(ref local_var_str) = tag_id__n {
9760        local_var_req_builder = match "multi" {
9761            "multi" => local_var_req_builder.query(
9762                &local_var_str
9763                    .into_iter()
9764                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9766            ),
9767            _ => local_var_req_builder.query(&[(
9768                "tag_id__n",
9769                &local_var_str
9770                    .into_iter()
9771                    .map(|p| p.to_string())
9772                    .collect::<Vec<String>>()
9773                    .join(",")
9774                    .to_string(),
9775            )]),
9776        };
9777    }
9778    if let Some(ref local_var_str) = updated_by_request {
9779        local_var_req_builder =
9780            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9781    }
9782    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9783        local_var_req_builder =
9784            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9785    }
9786    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9787        let local_var_key = local_var_apikey.key.clone();
9788        let local_var_value = match local_var_apikey.prefix {
9789            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9790            None => local_var_key,
9791        };
9792        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9793    };
9794
9795    let local_var_req = local_var_req_builder.build()?;
9796    let local_var_resp = local_var_client.execute(local_var_req).await?;
9797
9798    let local_var_status = local_var_resp.status();
9799    let local_var_content = local_var_resp.text().await?;
9800
9801    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9802        serde_json::from_str(&local_var_content).map_err(Error::from)
9803    } else {
9804        let local_var_entity: Option<TenancyTenantGroupsListError> =
9805            serde_json::from_str(&local_var_content).ok();
9806        let local_var_error = ResponseContent {
9807            status: local_var_status,
9808            content: local_var_content,
9809            entity: local_var_entity,
9810        };
9811        Err(Error::ResponseError(local_var_error))
9812    }
9813}
9814
9815/// Patch a tenant group object.
9816pub async fn tenancy_tenant_groups_partial_update(
9817    configuration: &configuration::Configuration,
9818    id: i32,
9819    patched_writable_tenant_group_request: Option<crate::models::PatchedWritableTenantGroupRequest>,
9820) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsPartialUpdateError>> {
9821    let local_var_configuration = configuration;
9822
9823    let local_var_client = &local_var_configuration.client;
9824
9825    let local_var_uri_str = format!(
9826        "{}/api/tenancy/tenant-groups/{id}/",
9827        local_var_configuration.base_path,
9828        id = id
9829    );
9830    let mut local_var_req_builder =
9831        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9832
9833    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9834        local_var_req_builder =
9835            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9836    }
9837    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9838        let local_var_key = local_var_apikey.key.clone();
9839        let local_var_value = match local_var_apikey.prefix {
9840            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9841            None => local_var_key,
9842        };
9843        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9844    };
9845    local_var_req_builder = local_var_req_builder.json(&patched_writable_tenant_group_request);
9846
9847    let local_var_req = local_var_req_builder.build()?;
9848    let local_var_resp = local_var_client.execute(local_var_req).await?;
9849
9850    let local_var_status = local_var_resp.status();
9851    let local_var_content = local_var_resp.text().await?;
9852
9853    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9854        serde_json::from_str(&local_var_content).map_err(Error::from)
9855    } else {
9856        let local_var_entity: Option<TenancyTenantGroupsPartialUpdateError> =
9857            serde_json::from_str(&local_var_content).ok();
9858        let local_var_error = ResponseContent {
9859            status: local_var_status,
9860            content: local_var_content,
9861            entity: local_var_entity,
9862        };
9863        Err(Error::ResponseError(local_var_error))
9864    }
9865}
9866
9867/// Get a tenant group object.
9868pub async fn tenancy_tenant_groups_retrieve(
9869    configuration: &configuration::Configuration,
9870    id: i32,
9871) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsRetrieveError>> {
9872    let local_var_configuration = configuration;
9873
9874    let local_var_client = &local_var_configuration.client;
9875
9876    let local_var_uri_str = format!(
9877        "{}/api/tenancy/tenant-groups/{id}/",
9878        local_var_configuration.base_path,
9879        id = id
9880    );
9881    let mut local_var_req_builder =
9882        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9883
9884    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9885        local_var_req_builder =
9886            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9887    }
9888    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9889        let local_var_key = local_var_apikey.key.clone();
9890        let local_var_value = match local_var_apikey.prefix {
9891            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9892            None => local_var_key,
9893        };
9894        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9895    };
9896
9897    let local_var_req = local_var_req_builder.build()?;
9898    let local_var_resp = local_var_client.execute(local_var_req).await?;
9899
9900    let local_var_status = local_var_resp.status();
9901    let local_var_content = local_var_resp.text().await?;
9902
9903    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9904        serde_json::from_str(&local_var_content).map_err(Error::from)
9905    } else {
9906        let local_var_entity: Option<TenancyTenantGroupsRetrieveError> =
9907            serde_json::from_str(&local_var_content).ok();
9908        let local_var_error = ResponseContent {
9909            status: local_var_status,
9910            content: local_var_content,
9911            entity: local_var_entity,
9912        };
9913        Err(Error::ResponseError(local_var_error))
9914    }
9915}
9916
9917/// Put a tenant group object.
9918pub async fn tenancy_tenant_groups_update(
9919    configuration: &configuration::Configuration,
9920    id: i32,
9921    writable_tenant_group_request: crate::models::WritableTenantGroupRequest,
9922) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsUpdateError>> {
9923    let local_var_configuration = configuration;
9924
9925    let local_var_client = &local_var_configuration.client;
9926
9927    let local_var_uri_str = format!(
9928        "{}/api/tenancy/tenant-groups/{id}/",
9929        local_var_configuration.base_path,
9930        id = id
9931    );
9932    let mut local_var_req_builder =
9933        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9934
9935    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9936        local_var_req_builder =
9937            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9938    }
9939    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9940        let local_var_key = local_var_apikey.key.clone();
9941        let local_var_value = match local_var_apikey.prefix {
9942            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9943            None => local_var_key,
9944        };
9945        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9946    };
9947    local_var_req_builder = local_var_req_builder.json(&writable_tenant_group_request);
9948
9949    let local_var_req = local_var_req_builder.build()?;
9950    let local_var_resp = local_var_client.execute(local_var_req).await?;
9951
9952    let local_var_status = local_var_resp.status();
9953    let local_var_content = local_var_resp.text().await?;
9954
9955    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9956        serde_json::from_str(&local_var_content).map_err(Error::from)
9957    } else {
9958        let local_var_entity: Option<TenancyTenantGroupsUpdateError> =
9959            serde_json::from_str(&local_var_content).ok();
9960        let local_var_error = ResponseContent {
9961            status: local_var_status,
9962            content: local_var_content,
9963            entity: local_var_entity,
9964        };
9965        Err(Error::ResponseError(local_var_error))
9966    }
9967}
9968
9969/// Delete a list of tenant objects.
9970pub async fn tenancy_tenants_bulk_destroy(
9971    configuration: &configuration::Configuration,
9972    tenant_request: Vec<crate::models::TenantRequest>,
9973) -> Result<(), Error<TenancyTenantsBulkDestroyError>> {
9974    let local_var_configuration = configuration;
9975
9976    let local_var_client = &local_var_configuration.client;
9977
9978    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
9979    let mut local_var_req_builder =
9980        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9981
9982    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9983        local_var_req_builder =
9984            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9985    }
9986    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9987        let local_var_key = local_var_apikey.key.clone();
9988        let local_var_value = match local_var_apikey.prefix {
9989            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9990            None => local_var_key,
9991        };
9992        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9993    };
9994    local_var_req_builder = local_var_req_builder.json(&tenant_request);
9995
9996    let local_var_req = local_var_req_builder.build()?;
9997    let local_var_resp = local_var_client.execute(local_var_req).await?;
9998
9999    let local_var_status = local_var_resp.status();
10000    let local_var_content = local_var_resp.text().await?;
10001
10002    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10003        Ok(())
10004    } else {
10005        let local_var_entity: Option<TenancyTenantsBulkDestroyError> =
10006            serde_json::from_str(&local_var_content).ok();
10007        let local_var_error = ResponseContent {
10008            status: local_var_status,
10009            content: local_var_content,
10010            entity: local_var_entity,
10011        };
10012        Err(Error::ResponseError(local_var_error))
10013    }
10014}
10015
10016/// Patch a list of tenant objects.
10017pub async fn tenancy_tenants_bulk_partial_update(
10018    configuration: &configuration::Configuration,
10019    tenant_request: Vec<crate::models::TenantRequest>,
10020) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkPartialUpdateError>> {
10021    let local_var_configuration = configuration;
10022
10023    let local_var_client = &local_var_configuration.client;
10024
10025    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10026    let mut local_var_req_builder =
10027        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10028
10029    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10030        local_var_req_builder =
10031            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10032    }
10033    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10034        let local_var_key = local_var_apikey.key.clone();
10035        let local_var_value = match local_var_apikey.prefix {
10036            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10037            None => local_var_key,
10038        };
10039        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10040    };
10041    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10042
10043    let local_var_req = local_var_req_builder.build()?;
10044    let local_var_resp = local_var_client.execute(local_var_req).await?;
10045
10046    let local_var_status = local_var_resp.status();
10047    let local_var_content = local_var_resp.text().await?;
10048
10049    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10050        serde_json::from_str(&local_var_content).map_err(Error::from)
10051    } else {
10052        let local_var_entity: Option<TenancyTenantsBulkPartialUpdateError> =
10053            serde_json::from_str(&local_var_content).ok();
10054        let local_var_error = ResponseContent {
10055            status: local_var_status,
10056            content: local_var_content,
10057            entity: local_var_entity,
10058        };
10059        Err(Error::ResponseError(local_var_error))
10060    }
10061}
10062
10063/// Put a list of tenant objects.
10064pub async fn tenancy_tenants_bulk_update(
10065    configuration: &configuration::Configuration,
10066    tenant_request: Vec<crate::models::TenantRequest>,
10067) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkUpdateError>> {
10068    let local_var_configuration = configuration;
10069
10070    let local_var_client = &local_var_configuration.client;
10071
10072    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10073    let mut local_var_req_builder =
10074        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10075
10076    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10077        local_var_req_builder =
10078            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10079    }
10080    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10081        let local_var_key = local_var_apikey.key.clone();
10082        let local_var_value = match local_var_apikey.prefix {
10083            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10084            None => local_var_key,
10085        };
10086        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10087    };
10088    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10089
10090    let local_var_req = local_var_req_builder.build()?;
10091    let local_var_resp = local_var_client.execute(local_var_req).await?;
10092
10093    let local_var_status = local_var_resp.status();
10094    let local_var_content = local_var_resp.text().await?;
10095
10096    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10097        serde_json::from_str(&local_var_content).map_err(Error::from)
10098    } else {
10099        let local_var_entity: Option<TenancyTenantsBulkUpdateError> =
10100            serde_json::from_str(&local_var_content).ok();
10101        let local_var_error = ResponseContent {
10102            status: local_var_status,
10103            content: local_var_content,
10104            entity: local_var_entity,
10105        };
10106        Err(Error::ResponseError(local_var_error))
10107    }
10108}
10109
10110/// Post a list of tenant objects.
10111pub async fn tenancy_tenants_create(
10112    configuration: &configuration::Configuration,
10113    tenant_request: crate::models::TenantRequest,
10114) -> Result<crate::models::Tenant, Error<TenancyTenantsCreateError>> {
10115    let local_var_configuration = configuration;
10116
10117    let local_var_client = &local_var_configuration.client;
10118
10119    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10120    let mut local_var_req_builder =
10121        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10122
10123    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10124        local_var_req_builder =
10125            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10126    }
10127    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10128        let local_var_key = local_var_apikey.key.clone();
10129        let local_var_value = match local_var_apikey.prefix {
10130            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10131            None => local_var_key,
10132        };
10133        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10134    };
10135    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10136
10137    let local_var_req = local_var_req_builder.build()?;
10138    let local_var_resp = local_var_client.execute(local_var_req).await?;
10139
10140    let local_var_status = local_var_resp.status();
10141    let local_var_content = local_var_resp.text().await?;
10142
10143    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10144        serde_json::from_str(&local_var_content).map_err(Error::from)
10145    } else {
10146        let local_var_entity: Option<TenancyTenantsCreateError> =
10147            serde_json::from_str(&local_var_content).ok();
10148        let local_var_error = ResponseContent {
10149            status: local_var_status,
10150            content: local_var_content,
10151            entity: local_var_entity,
10152        };
10153        Err(Error::ResponseError(local_var_error))
10154    }
10155}
10156
10157/// Delete a tenant object.
10158pub async fn tenancy_tenants_destroy(
10159    configuration: &configuration::Configuration,
10160    id: i32,
10161) -> Result<(), Error<TenancyTenantsDestroyError>> {
10162    let local_var_configuration = configuration;
10163
10164    let local_var_client = &local_var_configuration.client;
10165
10166    let local_var_uri_str = format!(
10167        "{}/api/tenancy/tenants/{id}/",
10168        local_var_configuration.base_path,
10169        id = id
10170    );
10171    let mut local_var_req_builder =
10172        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10173
10174    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10175        local_var_req_builder =
10176            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10177    }
10178    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10179        let local_var_key = local_var_apikey.key.clone();
10180        let local_var_value = match local_var_apikey.prefix {
10181            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10182            None => local_var_key,
10183        };
10184        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10185    };
10186
10187    let local_var_req = local_var_req_builder.build()?;
10188    let local_var_resp = local_var_client.execute(local_var_req).await?;
10189
10190    let local_var_status = local_var_resp.status();
10191    let local_var_content = local_var_resp.text().await?;
10192
10193    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10194        Ok(())
10195    } else {
10196        let local_var_entity: Option<TenancyTenantsDestroyError> =
10197            serde_json::from_str(&local_var_content).ok();
10198        let local_var_error = ResponseContent {
10199            status: local_var_status,
10200            content: local_var_content,
10201            entity: local_var_entity,
10202        };
10203        Err(Error::ResponseError(local_var_error))
10204    }
10205}
10206
10207/// Get a list of tenant objects.
10208pub async fn tenancy_tenants_list(
10209    configuration: &configuration::Configuration,
10210    contact: Option<Vec<i32>>,
10211    contact__n: Option<Vec<i32>>,
10212    contact_group: Option<Vec<String>>,
10213    contact_group__n: Option<Vec<String>>,
10214    contact_role: Option<Vec<i32>>,
10215    contact_role__n: Option<Vec<i32>>,
10216    created: Option<Vec<String>>,
10217    created__empty: Option<Vec<String>>,
10218    created__gt: Option<Vec<String>>,
10219    created__gte: Option<Vec<String>>,
10220    created__lt: Option<Vec<String>>,
10221    created__lte: Option<Vec<String>>,
10222    created__n: Option<Vec<String>>,
10223    created_by_request: Option<&str>,
10224    description: Option<Vec<String>>,
10225    description__empty: Option<bool>,
10226    description__ic: Option<Vec<String>>,
10227    description__ie: Option<Vec<String>>,
10228    description__iew: Option<Vec<String>>,
10229    description__iregex: Option<Vec<String>>,
10230    description__isw: Option<Vec<String>>,
10231    description__n: Option<Vec<String>>,
10232    description__nic: Option<Vec<String>>,
10233    description__nie: Option<Vec<String>>,
10234    description__niew: Option<Vec<String>>,
10235    description__nisw: Option<Vec<String>>,
10236    description__regex: Option<Vec<String>>,
10237    group: Option<Vec<String>>,
10238    group__n: Option<Vec<String>>,
10239    group_id: Option<Vec<String>>,
10240    group_id__n: Option<Vec<String>>,
10241    id: Option<Vec<i32>>,
10242    id__empty: Option<bool>,
10243    id__gt: Option<Vec<i32>>,
10244    id__gte: Option<Vec<i32>>,
10245    id__lt: Option<Vec<i32>>,
10246    id__lte: Option<Vec<i32>>,
10247    id__n: Option<Vec<i32>>,
10248    last_updated: Option<Vec<String>>,
10249    last_updated__empty: Option<Vec<String>>,
10250    last_updated__gt: Option<Vec<String>>,
10251    last_updated__gte: Option<Vec<String>>,
10252    last_updated__lt: Option<Vec<String>>,
10253    last_updated__lte: Option<Vec<String>>,
10254    last_updated__n: Option<Vec<String>>,
10255    limit: Option<i32>,
10256    modified_by_request: Option<&str>,
10257    name: Option<Vec<String>>,
10258    name__empty: Option<bool>,
10259    name__ic: Option<Vec<String>>,
10260    name__ie: Option<Vec<String>>,
10261    name__iew: Option<Vec<String>>,
10262    name__iregex: Option<Vec<String>>,
10263    name__isw: Option<Vec<String>>,
10264    name__n: Option<Vec<String>>,
10265    name__nic: Option<Vec<String>>,
10266    name__nie: Option<Vec<String>>,
10267    name__niew: Option<Vec<String>>,
10268    name__nisw: Option<Vec<String>>,
10269    name__regex: Option<Vec<String>>,
10270    offset: Option<i32>,
10271    ordering: Option<&str>,
10272    q: Option<&str>,
10273    slug: Option<Vec<String>>,
10274    slug__empty: Option<bool>,
10275    slug__ic: Option<Vec<String>>,
10276    slug__ie: Option<Vec<String>>,
10277    slug__iew: Option<Vec<String>>,
10278    slug__iregex: Option<Vec<String>>,
10279    slug__isw: Option<Vec<String>>,
10280    slug__n: Option<Vec<String>>,
10281    slug__nic: Option<Vec<String>>,
10282    slug__nie: Option<Vec<String>>,
10283    slug__niew: Option<Vec<String>>,
10284    slug__nisw: Option<Vec<String>>,
10285    slug__regex: Option<Vec<String>>,
10286    tag: Option<Vec<String>>,
10287    tag__n: Option<Vec<String>>,
10288    tag_id: Option<Vec<i32>>,
10289    tag_id__n: Option<Vec<i32>>,
10290    updated_by_request: Option<&str>,
10291) -> Result<crate::models::PaginatedTenantList, Error<TenancyTenantsListError>> {
10292    let local_var_configuration = configuration;
10293
10294    let local_var_client = &local_var_configuration.client;
10295
10296    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10297    let mut local_var_req_builder =
10298        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10299
10300    if let Some(ref local_var_str) = contact {
10301        local_var_req_builder = match "multi" {
10302            "multi" => local_var_req_builder.query(
10303                &local_var_str
10304                    .into_iter()
10305                    .map(|p| ("contact".to_owned(), p.to_string()))
10306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10307            ),
10308            _ => local_var_req_builder.query(&[(
10309                "contact",
10310                &local_var_str
10311                    .into_iter()
10312                    .map(|p| p.to_string())
10313                    .collect::<Vec<String>>()
10314                    .join(",")
10315                    .to_string(),
10316            )]),
10317        };
10318    }
10319    if let Some(ref local_var_str) = contact__n {
10320        local_var_req_builder = match "multi" {
10321            "multi" => local_var_req_builder.query(
10322                &local_var_str
10323                    .into_iter()
10324                    .map(|p| ("contact__n".to_owned(), p.to_string()))
10325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10326            ),
10327            _ => local_var_req_builder.query(&[(
10328                "contact__n",
10329                &local_var_str
10330                    .into_iter()
10331                    .map(|p| p.to_string())
10332                    .collect::<Vec<String>>()
10333                    .join(",")
10334                    .to_string(),
10335            )]),
10336        };
10337    }
10338    if let Some(ref local_var_str) = contact_group {
10339        local_var_req_builder = match "multi" {
10340            "multi" => local_var_req_builder.query(
10341                &local_var_str
10342                    .into_iter()
10343                    .map(|p| ("contact_group".to_owned(), p.to_string()))
10344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10345            ),
10346            _ => local_var_req_builder.query(&[(
10347                "contact_group",
10348                &local_var_str
10349                    .into_iter()
10350                    .map(|p| p.to_string())
10351                    .collect::<Vec<String>>()
10352                    .join(",")
10353                    .to_string(),
10354            )]),
10355        };
10356    }
10357    if let Some(ref local_var_str) = contact_group__n {
10358        local_var_req_builder = match "multi" {
10359            "multi" => local_var_req_builder.query(
10360                &local_var_str
10361                    .into_iter()
10362                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
10363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10364            ),
10365            _ => local_var_req_builder.query(&[(
10366                "contact_group__n",
10367                &local_var_str
10368                    .into_iter()
10369                    .map(|p| p.to_string())
10370                    .collect::<Vec<String>>()
10371                    .join(",")
10372                    .to_string(),
10373            )]),
10374        };
10375    }
10376    if let Some(ref local_var_str) = contact_role {
10377        local_var_req_builder = match "multi" {
10378            "multi" => local_var_req_builder.query(
10379                &local_var_str
10380                    .into_iter()
10381                    .map(|p| ("contact_role".to_owned(), p.to_string()))
10382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10383            ),
10384            _ => local_var_req_builder.query(&[(
10385                "contact_role",
10386                &local_var_str
10387                    .into_iter()
10388                    .map(|p| p.to_string())
10389                    .collect::<Vec<String>>()
10390                    .join(",")
10391                    .to_string(),
10392            )]),
10393        };
10394    }
10395    if let Some(ref local_var_str) = contact_role__n {
10396        local_var_req_builder = match "multi" {
10397            "multi" => local_var_req_builder.query(
10398                &local_var_str
10399                    .into_iter()
10400                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
10401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10402            ),
10403            _ => local_var_req_builder.query(&[(
10404                "contact_role__n",
10405                &local_var_str
10406                    .into_iter()
10407                    .map(|p| p.to_string())
10408                    .collect::<Vec<String>>()
10409                    .join(",")
10410                    .to_string(),
10411            )]),
10412        };
10413    }
10414    if let Some(ref local_var_str) = created {
10415        local_var_req_builder = match "multi" {
10416            "multi" => local_var_req_builder.query(
10417                &local_var_str
10418                    .into_iter()
10419                    .map(|p| ("created".to_owned(), p.to_string()))
10420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10421            ),
10422            _ => local_var_req_builder.query(&[(
10423                "created",
10424                &local_var_str
10425                    .into_iter()
10426                    .map(|p| p.to_string())
10427                    .collect::<Vec<String>>()
10428                    .join(",")
10429                    .to_string(),
10430            )]),
10431        };
10432    }
10433    if let Some(ref local_var_str) = created__empty {
10434        local_var_req_builder = match "multi" {
10435            "multi" => local_var_req_builder.query(
10436                &local_var_str
10437                    .into_iter()
10438                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10440            ),
10441            _ => local_var_req_builder.query(&[(
10442                "created__empty",
10443                &local_var_str
10444                    .into_iter()
10445                    .map(|p| p.to_string())
10446                    .collect::<Vec<String>>()
10447                    .join(",")
10448                    .to_string(),
10449            )]),
10450        };
10451    }
10452    if let Some(ref local_var_str) = created__gt {
10453        local_var_req_builder = match "multi" {
10454            "multi" => local_var_req_builder.query(
10455                &local_var_str
10456                    .into_iter()
10457                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10459            ),
10460            _ => local_var_req_builder.query(&[(
10461                "created__gt",
10462                &local_var_str
10463                    .into_iter()
10464                    .map(|p| p.to_string())
10465                    .collect::<Vec<String>>()
10466                    .join(",")
10467                    .to_string(),
10468            )]),
10469        };
10470    }
10471    if let Some(ref local_var_str) = created__gte {
10472        local_var_req_builder = match "multi" {
10473            "multi" => local_var_req_builder.query(
10474                &local_var_str
10475                    .into_iter()
10476                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10478            ),
10479            _ => local_var_req_builder.query(&[(
10480                "created__gte",
10481                &local_var_str
10482                    .into_iter()
10483                    .map(|p| p.to_string())
10484                    .collect::<Vec<String>>()
10485                    .join(",")
10486                    .to_string(),
10487            )]),
10488        };
10489    }
10490    if let Some(ref local_var_str) = created__lt {
10491        local_var_req_builder = match "multi" {
10492            "multi" => local_var_req_builder.query(
10493                &local_var_str
10494                    .into_iter()
10495                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10497            ),
10498            _ => local_var_req_builder.query(&[(
10499                "created__lt",
10500                &local_var_str
10501                    .into_iter()
10502                    .map(|p| p.to_string())
10503                    .collect::<Vec<String>>()
10504                    .join(",")
10505                    .to_string(),
10506            )]),
10507        };
10508    }
10509    if let Some(ref local_var_str) = created__lte {
10510        local_var_req_builder = match "multi" {
10511            "multi" => local_var_req_builder.query(
10512                &local_var_str
10513                    .into_iter()
10514                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10516            ),
10517            _ => local_var_req_builder.query(&[(
10518                "created__lte",
10519                &local_var_str
10520                    .into_iter()
10521                    .map(|p| p.to_string())
10522                    .collect::<Vec<String>>()
10523                    .join(",")
10524                    .to_string(),
10525            )]),
10526        };
10527    }
10528    if let Some(ref local_var_str) = created__n {
10529        local_var_req_builder = match "multi" {
10530            "multi" => local_var_req_builder.query(
10531                &local_var_str
10532                    .into_iter()
10533                    .map(|p| ("created__n".to_owned(), p.to_string()))
10534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10535            ),
10536            _ => local_var_req_builder.query(&[(
10537                "created__n",
10538                &local_var_str
10539                    .into_iter()
10540                    .map(|p| p.to_string())
10541                    .collect::<Vec<String>>()
10542                    .join(",")
10543                    .to_string(),
10544            )]),
10545        };
10546    }
10547    if let Some(ref local_var_str) = created_by_request {
10548        local_var_req_builder =
10549            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10550    }
10551    if let Some(ref local_var_str) = description {
10552        local_var_req_builder = match "multi" {
10553            "multi" => local_var_req_builder.query(
10554                &local_var_str
10555                    .into_iter()
10556                    .map(|p| ("description".to_owned(), p.to_string()))
10557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10558            ),
10559            _ => local_var_req_builder.query(&[(
10560                "description",
10561                &local_var_str
10562                    .into_iter()
10563                    .map(|p| p.to_string())
10564                    .collect::<Vec<String>>()
10565                    .join(",")
10566                    .to_string(),
10567            )]),
10568        };
10569    }
10570    if let Some(ref local_var_str) = description__empty {
10571        local_var_req_builder =
10572            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10573    }
10574    if let Some(ref local_var_str) = description__ic {
10575        local_var_req_builder = match "multi" {
10576            "multi" => local_var_req_builder.query(
10577                &local_var_str
10578                    .into_iter()
10579                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10581            ),
10582            _ => local_var_req_builder.query(&[(
10583                "description__ic",
10584                &local_var_str
10585                    .into_iter()
10586                    .map(|p| p.to_string())
10587                    .collect::<Vec<String>>()
10588                    .join(",")
10589                    .to_string(),
10590            )]),
10591        };
10592    }
10593    if let Some(ref local_var_str) = description__ie {
10594        local_var_req_builder = match "multi" {
10595            "multi" => local_var_req_builder.query(
10596                &local_var_str
10597                    .into_iter()
10598                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10600            ),
10601            _ => local_var_req_builder.query(&[(
10602                "description__ie",
10603                &local_var_str
10604                    .into_iter()
10605                    .map(|p| p.to_string())
10606                    .collect::<Vec<String>>()
10607                    .join(",")
10608                    .to_string(),
10609            )]),
10610        };
10611    }
10612    if let Some(ref local_var_str) = description__iew {
10613        local_var_req_builder = match "multi" {
10614            "multi" => local_var_req_builder.query(
10615                &local_var_str
10616                    .into_iter()
10617                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10619            ),
10620            _ => local_var_req_builder.query(&[(
10621                "description__iew",
10622                &local_var_str
10623                    .into_iter()
10624                    .map(|p| p.to_string())
10625                    .collect::<Vec<String>>()
10626                    .join(",")
10627                    .to_string(),
10628            )]),
10629        };
10630    }
10631    if let Some(ref local_var_str) = description__iregex {
10632        local_var_req_builder = match "multi" {
10633            "multi" => local_var_req_builder.query(
10634                &local_var_str
10635                    .into_iter()
10636                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10638            ),
10639            _ => local_var_req_builder.query(&[(
10640                "description__iregex",
10641                &local_var_str
10642                    .into_iter()
10643                    .map(|p| p.to_string())
10644                    .collect::<Vec<String>>()
10645                    .join(",")
10646                    .to_string(),
10647            )]),
10648        };
10649    }
10650    if let Some(ref local_var_str) = description__isw {
10651        local_var_req_builder = match "multi" {
10652            "multi" => local_var_req_builder.query(
10653                &local_var_str
10654                    .into_iter()
10655                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10657            ),
10658            _ => local_var_req_builder.query(&[(
10659                "description__isw",
10660                &local_var_str
10661                    .into_iter()
10662                    .map(|p| p.to_string())
10663                    .collect::<Vec<String>>()
10664                    .join(",")
10665                    .to_string(),
10666            )]),
10667        };
10668    }
10669    if let Some(ref local_var_str) = description__n {
10670        local_var_req_builder = match "multi" {
10671            "multi" => local_var_req_builder.query(
10672                &local_var_str
10673                    .into_iter()
10674                    .map(|p| ("description__n".to_owned(), p.to_string()))
10675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10676            ),
10677            _ => local_var_req_builder.query(&[(
10678                "description__n",
10679                &local_var_str
10680                    .into_iter()
10681                    .map(|p| p.to_string())
10682                    .collect::<Vec<String>>()
10683                    .join(",")
10684                    .to_string(),
10685            )]),
10686        };
10687    }
10688    if let Some(ref local_var_str) = description__nic {
10689        local_var_req_builder = match "multi" {
10690            "multi" => local_var_req_builder.query(
10691                &local_var_str
10692                    .into_iter()
10693                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10695            ),
10696            _ => local_var_req_builder.query(&[(
10697                "description__nic",
10698                &local_var_str
10699                    .into_iter()
10700                    .map(|p| p.to_string())
10701                    .collect::<Vec<String>>()
10702                    .join(",")
10703                    .to_string(),
10704            )]),
10705        };
10706    }
10707    if let Some(ref local_var_str) = description__nie {
10708        local_var_req_builder = match "multi" {
10709            "multi" => local_var_req_builder.query(
10710                &local_var_str
10711                    .into_iter()
10712                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10714            ),
10715            _ => local_var_req_builder.query(&[(
10716                "description__nie",
10717                &local_var_str
10718                    .into_iter()
10719                    .map(|p| p.to_string())
10720                    .collect::<Vec<String>>()
10721                    .join(",")
10722                    .to_string(),
10723            )]),
10724        };
10725    }
10726    if let Some(ref local_var_str) = description__niew {
10727        local_var_req_builder = match "multi" {
10728            "multi" => local_var_req_builder.query(
10729                &local_var_str
10730                    .into_iter()
10731                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10733            ),
10734            _ => local_var_req_builder.query(&[(
10735                "description__niew",
10736                &local_var_str
10737                    .into_iter()
10738                    .map(|p| p.to_string())
10739                    .collect::<Vec<String>>()
10740                    .join(",")
10741                    .to_string(),
10742            )]),
10743        };
10744    }
10745    if let Some(ref local_var_str) = description__nisw {
10746        local_var_req_builder = match "multi" {
10747            "multi" => local_var_req_builder.query(
10748                &local_var_str
10749                    .into_iter()
10750                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10752            ),
10753            _ => local_var_req_builder.query(&[(
10754                "description__nisw",
10755                &local_var_str
10756                    .into_iter()
10757                    .map(|p| p.to_string())
10758                    .collect::<Vec<String>>()
10759                    .join(",")
10760                    .to_string(),
10761            )]),
10762        };
10763    }
10764    if let Some(ref local_var_str) = description__regex {
10765        local_var_req_builder = match "multi" {
10766            "multi" => local_var_req_builder.query(
10767                &local_var_str
10768                    .into_iter()
10769                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10771            ),
10772            _ => local_var_req_builder.query(&[(
10773                "description__regex",
10774                &local_var_str
10775                    .into_iter()
10776                    .map(|p| p.to_string())
10777                    .collect::<Vec<String>>()
10778                    .join(",")
10779                    .to_string(),
10780            )]),
10781        };
10782    }
10783    if let Some(ref local_var_str) = group {
10784        local_var_req_builder = match "multi" {
10785            "multi" => local_var_req_builder.query(
10786                &local_var_str
10787                    .into_iter()
10788                    .map(|p| ("group".to_owned(), p.to_string()))
10789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10790            ),
10791            _ => local_var_req_builder.query(&[(
10792                "group",
10793                &local_var_str
10794                    .into_iter()
10795                    .map(|p| p.to_string())
10796                    .collect::<Vec<String>>()
10797                    .join(",")
10798                    .to_string(),
10799            )]),
10800        };
10801    }
10802    if let Some(ref local_var_str) = group__n {
10803        local_var_req_builder = match "multi" {
10804            "multi" => local_var_req_builder.query(
10805                &local_var_str
10806                    .into_iter()
10807                    .map(|p| ("group__n".to_owned(), p.to_string()))
10808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10809            ),
10810            _ => local_var_req_builder.query(&[(
10811                "group__n",
10812                &local_var_str
10813                    .into_iter()
10814                    .map(|p| p.to_string())
10815                    .collect::<Vec<String>>()
10816                    .join(",")
10817                    .to_string(),
10818            )]),
10819        };
10820    }
10821    if let Some(ref local_var_str) = group_id {
10822        local_var_req_builder = match "multi" {
10823            "multi" => local_var_req_builder.query(
10824                &local_var_str
10825                    .into_iter()
10826                    .map(|p| ("group_id".to_owned(), p.to_string()))
10827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10828            ),
10829            _ => local_var_req_builder.query(&[(
10830                "group_id",
10831                &local_var_str
10832                    .into_iter()
10833                    .map(|p| p.to_string())
10834                    .collect::<Vec<String>>()
10835                    .join(",")
10836                    .to_string(),
10837            )]),
10838        };
10839    }
10840    if let Some(ref local_var_str) = group_id__n {
10841        local_var_req_builder = match "multi" {
10842            "multi" => local_var_req_builder.query(
10843                &local_var_str
10844                    .into_iter()
10845                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
10846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10847            ),
10848            _ => local_var_req_builder.query(&[(
10849                "group_id__n",
10850                &local_var_str
10851                    .into_iter()
10852                    .map(|p| p.to_string())
10853                    .collect::<Vec<String>>()
10854                    .join(",")
10855                    .to_string(),
10856            )]),
10857        };
10858    }
10859    if let Some(ref local_var_str) = id {
10860        local_var_req_builder = match "multi" {
10861            "multi" => local_var_req_builder.query(
10862                &local_var_str
10863                    .into_iter()
10864                    .map(|p| ("id".to_owned(), p.to_string()))
10865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10866            ),
10867            _ => local_var_req_builder.query(&[(
10868                "id",
10869                &local_var_str
10870                    .into_iter()
10871                    .map(|p| p.to_string())
10872                    .collect::<Vec<String>>()
10873                    .join(",")
10874                    .to_string(),
10875            )]),
10876        };
10877    }
10878    if let Some(ref local_var_str) = id__empty {
10879        local_var_req_builder =
10880            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10881    }
10882    if let Some(ref local_var_str) = id__gt {
10883        local_var_req_builder = match "multi" {
10884            "multi" => local_var_req_builder.query(
10885                &local_var_str
10886                    .into_iter()
10887                    .map(|p| ("id__gt".to_owned(), p.to_string()))
10888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10889            ),
10890            _ => local_var_req_builder.query(&[(
10891                "id__gt",
10892                &local_var_str
10893                    .into_iter()
10894                    .map(|p| p.to_string())
10895                    .collect::<Vec<String>>()
10896                    .join(",")
10897                    .to_string(),
10898            )]),
10899        };
10900    }
10901    if let Some(ref local_var_str) = id__gte {
10902        local_var_req_builder = match "multi" {
10903            "multi" => local_var_req_builder.query(
10904                &local_var_str
10905                    .into_iter()
10906                    .map(|p| ("id__gte".to_owned(), p.to_string()))
10907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10908            ),
10909            _ => local_var_req_builder.query(&[(
10910                "id__gte",
10911                &local_var_str
10912                    .into_iter()
10913                    .map(|p| p.to_string())
10914                    .collect::<Vec<String>>()
10915                    .join(",")
10916                    .to_string(),
10917            )]),
10918        };
10919    }
10920    if let Some(ref local_var_str) = id__lt {
10921        local_var_req_builder = match "multi" {
10922            "multi" => local_var_req_builder.query(
10923                &local_var_str
10924                    .into_iter()
10925                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10927            ),
10928            _ => local_var_req_builder.query(&[(
10929                "id__lt",
10930                &local_var_str
10931                    .into_iter()
10932                    .map(|p| p.to_string())
10933                    .collect::<Vec<String>>()
10934                    .join(",")
10935                    .to_string(),
10936            )]),
10937        };
10938    }
10939    if let Some(ref local_var_str) = id__lte {
10940        local_var_req_builder = match "multi" {
10941            "multi" => local_var_req_builder.query(
10942                &local_var_str
10943                    .into_iter()
10944                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10946            ),
10947            _ => local_var_req_builder.query(&[(
10948                "id__lte",
10949                &local_var_str
10950                    .into_iter()
10951                    .map(|p| p.to_string())
10952                    .collect::<Vec<String>>()
10953                    .join(",")
10954                    .to_string(),
10955            )]),
10956        };
10957    }
10958    if let Some(ref local_var_str) = id__n {
10959        local_var_req_builder = match "multi" {
10960            "multi" => local_var_req_builder.query(
10961                &local_var_str
10962                    .into_iter()
10963                    .map(|p| ("id__n".to_owned(), p.to_string()))
10964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10965            ),
10966            _ => local_var_req_builder.query(&[(
10967                "id__n",
10968                &local_var_str
10969                    .into_iter()
10970                    .map(|p| p.to_string())
10971                    .collect::<Vec<String>>()
10972                    .join(",")
10973                    .to_string(),
10974            )]),
10975        };
10976    }
10977    if let Some(ref local_var_str) = last_updated {
10978        local_var_req_builder = match "multi" {
10979            "multi" => local_var_req_builder.query(
10980                &local_var_str
10981                    .into_iter()
10982                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10984            ),
10985            _ => local_var_req_builder.query(&[(
10986                "last_updated",
10987                &local_var_str
10988                    .into_iter()
10989                    .map(|p| p.to_string())
10990                    .collect::<Vec<String>>()
10991                    .join(",")
10992                    .to_string(),
10993            )]),
10994        };
10995    }
10996    if let Some(ref local_var_str) = last_updated__empty {
10997        local_var_req_builder = match "multi" {
10998            "multi" => local_var_req_builder.query(
10999                &local_var_str
11000                    .into_iter()
11001                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11003            ),
11004            _ => local_var_req_builder.query(&[(
11005                "last_updated__empty",
11006                &local_var_str
11007                    .into_iter()
11008                    .map(|p| p.to_string())
11009                    .collect::<Vec<String>>()
11010                    .join(",")
11011                    .to_string(),
11012            )]),
11013        };
11014    }
11015    if let Some(ref local_var_str) = last_updated__gt {
11016        local_var_req_builder = match "multi" {
11017            "multi" => local_var_req_builder.query(
11018                &local_var_str
11019                    .into_iter()
11020                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11022            ),
11023            _ => local_var_req_builder.query(&[(
11024                "last_updated__gt",
11025                &local_var_str
11026                    .into_iter()
11027                    .map(|p| p.to_string())
11028                    .collect::<Vec<String>>()
11029                    .join(",")
11030                    .to_string(),
11031            )]),
11032        };
11033    }
11034    if let Some(ref local_var_str) = last_updated__gte {
11035        local_var_req_builder = match "multi" {
11036            "multi" => local_var_req_builder.query(
11037                &local_var_str
11038                    .into_iter()
11039                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11041            ),
11042            _ => local_var_req_builder.query(&[(
11043                "last_updated__gte",
11044                &local_var_str
11045                    .into_iter()
11046                    .map(|p| p.to_string())
11047                    .collect::<Vec<String>>()
11048                    .join(",")
11049                    .to_string(),
11050            )]),
11051        };
11052    }
11053    if let Some(ref local_var_str) = last_updated__lt {
11054        local_var_req_builder = match "multi" {
11055            "multi" => local_var_req_builder.query(
11056                &local_var_str
11057                    .into_iter()
11058                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11060            ),
11061            _ => local_var_req_builder.query(&[(
11062                "last_updated__lt",
11063                &local_var_str
11064                    .into_iter()
11065                    .map(|p| p.to_string())
11066                    .collect::<Vec<String>>()
11067                    .join(",")
11068                    .to_string(),
11069            )]),
11070        };
11071    }
11072    if let Some(ref local_var_str) = last_updated__lte {
11073        local_var_req_builder = match "multi" {
11074            "multi" => local_var_req_builder.query(
11075                &local_var_str
11076                    .into_iter()
11077                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11079            ),
11080            _ => local_var_req_builder.query(&[(
11081                "last_updated__lte",
11082                &local_var_str
11083                    .into_iter()
11084                    .map(|p| p.to_string())
11085                    .collect::<Vec<String>>()
11086                    .join(",")
11087                    .to_string(),
11088            )]),
11089        };
11090    }
11091    if let Some(ref local_var_str) = last_updated__n {
11092        local_var_req_builder = match "multi" {
11093            "multi" => local_var_req_builder.query(
11094                &local_var_str
11095                    .into_iter()
11096                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11098            ),
11099            _ => local_var_req_builder.query(&[(
11100                "last_updated__n",
11101                &local_var_str
11102                    .into_iter()
11103                    .map(|p| p.to_string())
11104                    .collect::<Vec<String>>()
11105                    .join(",")
11106                    .to_string(),
11107            )]),
11108        };
11109    }
11110    if let Some(ref local_var_str) = limit {
11111        local_var_req_builder =
11112            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11113    }
11114    if let Some(ref local_var_str) = modified_by_request {
11115        local_var_req_builder =
11116            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
11117    }
11118    if let Some(ref local_var_str) = name {
11119        local_var_req_builder = match "multi" {
11120            "multi" => local_var_req_builder.query(
11121                &local_var_str
11122                    .into_iter()
11123                    .map(|p| ("name".to_owned(), p.to_string()))
11124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11125            ),
11126            _ => local_var_req_builder.query(&[(
11127                "name",
11128                &local_var_str
11129                    .into_iter()
11130                    .map(|p| p.to_string())
11131                    .collect::<Vec<String>>()
11132                    .join(",")
11133                    .to_string(),
11134            )]),
11135        };
11136    }
11137    if let Some(ref local_var_str) = name__empty {
11138        local_var_req_builder =
11139            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
11140    }
11141    if let Some(ref local_var_str) = name__ic {
11142        local_var_req_builder = match "multi" {
11143            "multi" => local_var_req_builder.query(
11144                &local_var_str
11145                    .into_iter()
11146                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11147                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11148            ),
11149            _ => local_var_req_builder.query(&[(
11150                "name__ic",
11151                &local_var_str
11152                    .into_iter()
11153                    .map(|p| p.to_string())
11154                    .collect::<Vec<String>>()
11155                    .join(",")
11156                    .to_string(),
11157            )]),
11158        };
11159    }
11160    if let Some(ref local_var_str) = name__ie {
11161        local_var_req_builder = match "multi" {
11162            "multi" => local_var_req_builder.query(
11163                &local_var_str
11164                    .into_iter()
11165                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11166                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11167            ),
11168            _ => local_var_req_builder.query(&[(
11169                "name__ie",
11170                &local_var_str
11171                    .into_iter()
11172                    .map(|p| p.to_string())
11173                    .collect::<Vec<String>>()
11174                    .join(",")
11175                    .to_string(),
11176            )]),
11177        };
11178    }
11179    if let Some(ref local_var_str) = name__iew {
11180        local_var_req_builder = match "multi" {
11181            "multi" => local_var_req_builder.query(
11182                &local_var_str
11183                    .into_iter()
11184                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11185                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11186            ),
11187            _ => local_var_req_builder.query(&[(
11188                "name__iew",
11189                &local_var_str
11190                    .into_iter()
11191                    .map(|p| p.to_string())
11192                    .collect::<Vec<String>>()
11193                    .join(",")
11194                    .to_string(),
11195            )]),
11196        };
11197    }
11198    if let Some(ref local_var_str) = name__iregex {
11199        local_var_req_builder = match "multi" {
11200            "multi" => local_var_req_builder.query(
11201                &local_var_str
11202                    .into_iter()
11203                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
11204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11205            ),
11206            _ => local_var_req_builder.query(&[(
11207                "name__iregex",
11208                &local_var_str
11209                    .into_iter()
11210                    .map(|p| p.to_string())
11211                    .collect::<Vec<String>>()
11212                    .join(",")
11213                    .to_string(),
11214            )]),
11215        };
11216    }
11217    if let Some(ref local_var_str) = name__isw {
11218        local_var_req_builder = match "multi" {
11219            "multi" => local_var_req_builder.query(
11220                &local_var_str
11221                    .into_iter()
11222                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11224            ),
11225            _ => local_var_req_builder.query(&[(
11226                "name__isw",
11227                &local_var_str
11228                    .into_iter()
11229                    .map(|p| p.to_string())
11230                    .collect::<Vec<String>>()
11231                    .join(",")
11232                    .to_string(),
11233            )]),
11234        };
11235    }
11236    if let Some(ref local_var_str) = name__n {
11237        local_var_req_builder = match "multi" {
11238            "multi" => local_var_req_builder.query(
11239                &local_var_str
11240                    .into_iter()
11241                    .map(|p| ("name__n".to_owned(), p.to_string()))
11242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11243            ),
11244            _ => local_var_req_builder.query(&[(
11245                "name__n",
11246                &local_var_str
11247                    .into_iter()
11248                    .map(|p| p.to_string())
11249                    .collect::<Vec<String>>()
11250                    .join(",")
11251                    .to_string(),
11252            )]),
11253        };
11254    }
11255    if let Some(ref local_var_str) = name__nic {
11256        local_var_req_builder = match "multi" {
11257            "multi" => local_var_req_builder.query(
11258                &local_var_str
11259                    .into_iter()
11260                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11262            ),
11263            _ => local_var_req_builder.query(&[(
11264                "name__nic",
11265                &local_var_str
11266                    .into_iter()
11267                    .map(|p| p.to_string())
11268                    .collect::<Vec<String>>()
11269                    .join(",")
11270                    .to_string(),
11271            )]),
11272        };
11273    }
11274    if let Some(ref local_var_str) = name__nie {
11275        local_var_req_builder = match "multi" {
11276            "multi" => local_var_req_builder.query(
11277                &local_var_str
11278                    .into_iter()
11279                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11281            ),
11282            _ => local_var_req_builder.query(&[(
11283                "name__nie",
11284                &local_var_str
11285                    .into_iter()
11286                    .map(|p| p.to_string())
11287                    .collect::<Vec<String>>()
11288                    .join(",")
11289                    .to_string(),
11290            )]),
11291        };
11292    }
11293    if let Some(ref local_var_str) = name__niew {
11294        local_var_req_builder = match "multi" {
11295            "multi" => local_var_req_builder.query(
11296                &local_var_str
11297                    .into_iter()
11298                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11300            ),
11301            _ => local_var_req_builder.query(&[(
11302                "name__niew",
11303                &local_var_str
11304                    .into_iter()
11305                    .map(|p| p.to_string())
11306                    .collect::<Vec<String>>()
11307                    .join(",")
11308                    .to_string(),
11309            )]),
11310        };
11311    }
11312    if let Some(ref local_var_str) = name__nisw {
11313        local_var_req_builder = match "multi" {
11314            "multi" => local_var_req_builder.query(
11315                &local_var_str
11316                    .into_iter()
11317                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11319            ),
11320            _ => local_var_req_builder.query(&[(
11321                "name__nisw",
11322                &local_var_str
11323                    .into_iter()
11324                    .map(|p| p.to_string())
11325                    .collect::<Vec<String>>()
11326                    .join(",")
11327                    .to_string(),
11328            )]),
11329        };
11330    }
11331    if let Some(ref local_var_str) = name__regex {
11332        local_var_req_builder = match "multi" {
11333            "multi" => local_var_req_builder.query(
11334                &local_var_str
11335                    .into_iter()
11336                    .map(|p| ("name__regex".to_owned(), p.to_string()))
11337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11338            ),
11339            _ => local_var_req_builder.query(&[(
11340                "name__regex",
11341                &local_var_str
11342                    .into_iter()
11343                    .map(|p| p.to_string())
11344                    .collect::<Vec<String>>()
11345                    .join(",")
11346                    .to_string(),
11347            )]),
11348        };
11349    }
11350    if let Some(ref local_var_str) = offset {
11351        local_var_req_builder =
11352            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11353    }
11354    if let Some(ref local_var_str) = ordering {
11355        local_var_req_builder =
11356            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11357    }
11358    if let Some(ref local_var_str) = q {
11359        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11360    }
11361    if let Some(ref local_var_str) = slug {
11362        local_var_req_builder = match "multi" {
11363            "multi" => local_var_req_builder.query(
11364                &local_var_str
11365                    .into_iter()
11366                    .map(|p| ("slug".to_owned(), p.to_string()))
11367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11368            ),
11369            _ => local_var_req_builder.query(&[(
11370                "slug",
11371                &local_var_str
11372                    .into_iter()
11373                    .map(|p| p.to_string())
11374                    .collect::<Vec<String>>()
11375                    .join(",")
11376                    .to_string(),
11377            )]),
11378        };
11379    }
11380    if let Some(ref local_var_str) = slug__empty {
11381        local_var_req_builder =
11382            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
11383    }
11384    if let Some(ref local_var_str) = slug__ic {
11385        local_var_req_builder = match "multi" {
11386            "multi" => local_var_req_builder.query(
11387                &local_var_str
11388                    .into_iter()
11389                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
11390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11391            ),
11392            _ => local_var_req_builder.query(&[(
11393                "slug__ic",
11394                &local_var_str
11395                    .into_iter()
11396                    .map(|p| p.to_string())
11397                    .collect::<Vec<String>>()
11398                    .join(",")
11399                    .to_string(),
11400            )]),
11401        };
11402    }
11403    if let Some(ref local_var_str) = slug__ie {
11404        local_var_req_builder = match "multi" {
11405            "multi" => local_var_req_builder.query(
11406                &local_var_str
11407                    .into_iter()
11408                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
11409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11410            ),
11411            _ => local_var_req_builder.query(&[(
11412                "slug__ie",
11413                &local_var_str
11414                    .into_iter()
11415                    .map(|p| p.to_string())
11416                    .collect::<Vec<String>>()
11417                    .join(",")
11418                    .to_string(),
11419            )]),
11420        };
11421    }
11422    if let Some(ref local_var_str) = slug__iew {
11423        local_var_req_builder = match "multi" {
11424            "multi" => local_var_req_builder.query(
11425                &local_var_str
11426                    .into_iter()
11427                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
11428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11429            ),
11430            _ => local_var_req_builder.query(&[(
11431                "slug__iew",
11432                &local_var_str
11433                    .into_iter()
11434                    .map(|p| p.to_string())
11435                    .collect::<Vec<String>>()
11436                    .join(",")
11437                    .to_string(),
11438            )]),
11439        };
11440    }
11441    if let Some(ref local_var_str) = slug__iregex {
11442        local_var_req_builder = match "multi" {
11443            "multi" => local_var_req_builder.query(
11444                &local_var_str
11445                    .into_iter()
11446                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
11447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11448            ),
11449            _ => local_var_req_builder.query(&[(
11450                "slug__iregex",
11451                &local_var_str
11452                    .into_iter()
11453                    .map(|p| p.to_string())
11454                    .collect::<Vec<String>>()
11455                    .join(",")
11456                    .to_string(),
11457            )]),
11458        };
11459    }
11460    if let Some(ref local_var_str) = slug__isw {
11461        local_var_req_builder = match "multi" {
11462            "multi" => local_var_req_builder.query(
11463                &local_var_str
11464                    .into_iter()
11465                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
11466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11467            ),
11468            _ => local_var_req_builder.query(&[(
11469                "slug__isw",
11470                &local_var_str
11471                    .into_iter()
11472                    .map(|p| p.to_string())
11473                    .collect::<Vec<String>>()
11474                    .join(",")
11475                    .to_string(),
11476            )]),
11477        };
11478    }
11479    if let Some(ref local_var_str) = slug__n {
11480        local_var_req_builder = match "multi" {
11481            "multi" => local_var_req_builder.query(
11482                &local_var_str
11483                    .into_iter()
11484                    .map(|p| ("slug__n".to_owned(), p.to_string()))
11485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11486            ),
11487            _ => local_var_req_builder.query(&[(
11488                "slug__n",
11489                &local_var_str
11490                    .into_iter()
11491                    .map(|p| p.to_string())
11492                    .collect::<Vec<String>>()
11493                    .join(",")
11494                    .to_string(),
11495            )]),
11496        };
11497    }
11498    if let Some(ref local_var_str) = slug__nic {
11499        local_var_req_builder = match "multi" {
11500            "multi" => local_var_req_builder.query(
11501                &local_var_str
11502                    .into_iter()
11503                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
11504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11505            ),
11506            _ => local_var_req_builder.query(&[(
11507                "slug__nic",
11508                &local_var_str
11509                    .into_iter()
11510                    .map(|p| p.to_string())
11511                    .collect::<Vec<String>>()
11512                    .join(",")
11513                    .to_string(),
11514            )]),
11515        };
11516    }
11517    if let Some(ref local_var_str) = slug__nie {
11518        local_var_req_builder = match "multi" {
11519            "multi" => local_var_req_builder.query(
11520                &local_var_str
11521                    .into_iter()
11522                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
11523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11524            ),
11525            _ => local_var_req_builder.query(&[(
11526                "slug__nie",
11527                &local_var_str
11528                    .into_iter()
11529                    .map(|p| p.to_string())
11530                    .collect::<Vec<String>>()
11531                    .join(",")
11532                    .to_string(),
11533            )]),
11534        };
11535    }
11536    if let Some(ref local_var_str) = slug__niew {
11537        local_var_req_builder = match "multi" {
11538            "multi" => local_var_req_builder.query(
11539                &local_var_str
11540                    .into_iter()
11541                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
11542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11543            ),
11544            _ => local_var_req_builder.query(&[(
11545                "slug__niew",
11546                &local_var_str
11547                    .into_iter()
11548                    .map(|p| p.to_string())
11549                    .collect::<Vec<String>>()
11550                    .join(",")
11551                    .to_string(),
11552            )]),
11553        };
11554    }
11555    if let Some(ref local_var_str) = slug__nisw {
11556        local_var_req_builder = match "multi" {
11557            "multi" => local_var_req_builder.query(
11558                &local_var_str
11559                    .into_iter()
11560                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
11561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11562            ),
11563            _ => local_var_req_builder.query(&[(
11564                "slug__nisw",
11565                &local_var_str
11566                    .into_iter()
11567                    .map(|p| p.to_string())
11568                    .collect::<Vec<String>>()
11569                    .join(",")
11570                    .to_string(),
11571            )]),
11572        };
11573    }
11574    if let Some(ref local_var_str) = slug__regex {
11575        local_var_req_builder = match "multi" {
11576            "multi" => local_var_req_builder.query(
11577                &local_var_str
11578                    .into_iter()
11579                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
11580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11581            ),
11582            _ => local_var_req_builder.query(&[(
11583                "slug__regex",
11584                &local_var_str
11585                    .into_iter()
11586                    .map(|p| p.to_string())
11587                    .collect::<Vec<String>>()
11588                    .join(",")
11589                    .to_string(),
11590            )]),
11591        };
11592    }
11593    if let Some(ref local_var_str) = tag {
11594        local_var_req_builder = match "multi" {
11595            "multi" => local_var_req_builder.query(
11596                &local_var_str
11597                    .into_iter()
11598                    .map(|p| ("tag".to_owned(), p.to_string()))
11599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11600            ),
11601            _ => local_var_req_builder.query(&[(
11602                "tag",
11603                &local_var_str
11604                    .into_iter()
11605                    .map(|p| p.to_string())
11606                    .collect::<Vec<String>>()
11607                    .join(",")
11608                    .to_string(),
11609            )]),
11610        };
11611    }
11612    if let Some(ref local_var_str) = tag__n {
11613        local_var_req_builder = match "multi" {
11614            "multi" => local_var_req_builder.query(
11615                &local_var_str
11616                    .into_iter()
11617                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11619            ),
11620            _ => local_var_req_builder.query(&[(
11621                "tag__n",
11622                &local_var_str
11623                    .into_iter()
11624                    .map(|p| p.to_string())
11625                    .collect::<Vec<String>>()
11626                    .join(",")
11627                    .to_string(),
11628            )]),
11629        };
11630    }
11631    if let Some(ref local_var_str) = tag_id {
11632        local_var_req_builder = match "multi" {
11633            "multi" => local_var_req_builder.query(
11634                &local_var_str
11635                    .into_iter()
11636                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11638            ),
11639            _ => local_var_req_builder.query(&[(
11640                "tag_id",
11641                &local_var_str
11642                    .into_iter()
11643                    .map(|p| p.to_string())
11644                    .collect::<Vec<String>>()
11645                    .join(",")
11646                    .to_string(),
11647            )]),
11648        };
11649    }
11650    if let Some(ref local_var_str) = tag_id__n {
11651        local_var_req_builder = match "multi" {
11652            "multi" => local_var_req_builder.query(
11653                &local_var_str
11654                    .into_iter()
11655                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11657            ),
11658            _ => local_var_req_builder.query(&[(
11659                "tag_id__n",
11660                &local_var_str
11661                    .into_iter()
11662                    .map(|p| p.to_string())
11663                    .collect::<Vec<String>>()
11664                    .join(",")
11665                    .to_string(),
11666            )]),
11667        };
11668    }
11669    if let Some(ref local_var_str) = updated_by_request {
11670        local_var_req_builder =
11671            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11672    }
11673    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11674        local_var_req_builder =
11675            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11676    }
11677    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11678        let local_var_key = local_var_apikey.key.clone();
11679        let local_var_value = match local_var_apikey.prefix {
11680            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11681            None => local_var_key,
11682        };
11683        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11684    };
11685
11686    let local_var_req = local_var_req_builder.build()?;
11687    let local_var_resp = local_var_client.execute(local_var_req).await?;
11688
11689    let local_var_status = local_var_resp.status();
11690    let local_var_content = local_var_resp.text().await?;
11691
11692    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11693        serde_json::from_str(&local_var_content).map_err(Error::from)
11694    } else {
11695        let local_var_entity: Option<TenancyTenantsListError> =
11696            serde_json::from_str(&local_var_content).ok();
11697        let local_var_error = ResponseContent {
11698            status: local_var_status,
11699            content: local_var_content,
11700            entity: local_var_entity,
11701        };
11702        Err(Error::ResponseError(local_var_error))
11703    }
11704}
11705
11706/// Patch a tenant object.
11707pub async fn tenancy_tenants_partial_update(
11708    configuration: &configuration::Configuration,
11709    id: i32,
11710    patched_tenant_request: Option<crate::models::PatchedTenantRequest>,
11711) -> Result<crate::models::Tenant, Error<TenancyTenantsPartialUpdateError>> {
11712    let local_var_configuration = configuration;
11713
11714    let local_var_client = &local_var_configuration.client;
11715
11716    let local_var_uri_str = format!(
11717        "{}/api/tenancy/tenants/{id}/",
11718        local_var_configuration.base_path,
11719        id = id
11720    );
11721    let mut local_var_req_builder =
11722        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11723
11724    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11725        local_var_req_builder =
11726            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11727    }
11728    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11729        let local_var_key = local_var_apikey.key.clone();
11730        let local_var_value = match local_var_apikey.prefix {
11731            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11732            None => local_var_key,
11733        };
11734        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11735    };
11736    local_var_req_builder = local_var_req_builder.json(&patched_tenant_request);
11737
11738    let local_var_req = local_var_req_builder.build()?;
11739    let local_var_resp = local_var_client.execute(local_var_req).await?;
11740
11741    let local_var_status = local_var_resp.status();
11742    let local_var_content = local_var_resp.text().await?;
11743
11744    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11745        serde_json::from_str(&local_var_content).map_err(Error::from)
11746    } else {
11747        let local_var_entity: Option<TenancyTenantsPartialUpdateError> =
11748            serde_json::from_str(&local_var_content).ok();
11749        let local_var_error = ResponseContent {
11750            status: local_var_status,
11751            content: local_var_content,
11752            entity: local_var_entity,
11753        };
11754        Err(Error::ResponseError(local_var_error))
11755    }
11756}
11757
11758/// Get a tenant object.
11759pub async fn tenancy_tenants_retrieve(
11760    configuration: &configuration::Configuration,
11761    id: i32,
11762) -> Result<crate::models::Tenant, Error<TenancyTenantsRetrieveError>> {
11763    let local_var_configuration = configuration;
11764
11765    let local_var_client = &local_var_configuration.client;
11766
11767    let local_var_uri_str = format!(
11768        "{}/api/tenancy/tenants/{id}/",
11769        local_var_configuration.base_path,
11770        id = id
11771    );
11772    let mut local_var_req_builder =
11773        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11774
11775    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11776        local_var_req_builder =
11777            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11778    }
11779    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11780        let local_var_key = local_var_apikey.key.clone();
11781        let local_var_value = match local_var_apikey.prefix {
11782            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11783            None => local_var_key,
11784        };
11785        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11786    };
11787
11788    let local_var_req = local_var_req_builder.build()?;
11789    let local_var_resp = local_var_client.execute(local_var_req).await?;
11790
11791    let local_var_status = local_var_resp.status();
11792    let local_var_content = local_var_resp.text().await?;
11793
11794    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11795        serde_json::from_str(&local_var_content).map_err(Error::from)
11796    } else {
11797        let local_var_entity: Option<TenancyTenantsRetrieveError> =
11798            serde_json::from_str(&local_var_content).ok();
11799        let local_var_error = ResponseContent {
11800            status: local_var_status,
11801            content: local_var_content,
11802            entity: local_var_entity,
11803        };
11804        Err(Error::ResponseError(local_var_error))
11805    }
11806}
11807
11808/// Put a tenant object.
11809pub async fn tenancy_tenants_update(
11810    configuration: &configuration::Configuration,
11811    id: i32,
11812    tenant_request: crate::models::TenantRequest,
11813) -> Result<crate::models::Tenant, Error<TenancyTenantsUpdateError>> {
11814    let local_var_configuration = configuration;
11815
11816    let local_var_client = &local_var_configuration.client;
11817
11818    let local_var_uri_str = format!(
11819        "{}/api/tenancy/tenants/{id}/",
11820        local_var_configuration.base_path,
11821        id = id
11822    );
11823    let mut local_var_req_builder =
11824        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11825
11826    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11827        local_var_req_builder =
11828            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11829    }
11830    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11831        let local_var_key = local_var_apikey.key.clone();
11832        let local_var_value = match local_var_apikey.prefix {
11833            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11834            None => local_var_key,
11835        };
11836        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11837    };
11838    local_var_req_builder = local_var_req_builder.json(&tenant_request);
11839
11840    let local_var_req = local_var_req_builder.build()?;
11841    let local_var_resp = local_var_client.execute(local_var_req).await?;
11842
11843    let local_var_status = local_var_resp.status();
11844    let local_var_content = local_var_resp.text().await?;
11845
11846    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11847        serde_json::from_str(&local_var_content).map_err(Error::from)
11848    } else {
11849        let local_var_entity: Option<TenancyTenantsUpdateError> =
11850            serde_json::from_str(&local_var_content).ok();
11851        let local_var_error = ResponseContent {
11852            status: local_var_status,
11853            content: local_var_content,
11854            entity: local_var_entity,
11855        };
11856        Err(Error::ResponseError(local_var_error))
11857    }
11858}
netbox_openapi/apis/tenancy_api.rs

netbox_openapi/apis/
tenancy_api.rs
