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.5.9-Docker-4.0.2 (4.5)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`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    tenancy_contact_assignments_create_request: crate::models::TenancyContactAssignmentsCreateRequest,
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(&tenancy_contact_assignments_create_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<Vec<String>>,
689    object_type__n: Option<Vec<String>>,
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    priority__empty: Option<bool>,
696    priority__ic: Option<Vec<String>>,
697    priority__ie: Option<Vec<String>>,
698    priority__iew: Option<Vec<String>>,
699    priority__iregex: Option<Vec<String>>,
700    priority__isw: Option<Vec<String>>,
701    priority__n: Option<&str>,
702    priority__nic: Option<Vec<String>>,
703    priority__nie: Option<Vec<String>>,
704    priority__niew: Option<Vec<String>>,
705    priority__nisw: Option<Vec<String>>,
706    priority__regex: Option<Vec<String>>,
707    q: Option<&str>,
708    role: Option<Vec<String>>,
709    role__n: Option<Vec<String>>,
710    role_id: Option<Vec<i32>>,
711    role_id__n: Option<Vec<i32>>,
712    tag: Option<Vec<String>>,
713    tag__n: Option<Vec<String>>,
714    tag_id: Option<Vec<i32>>,
715    tag_id__n: Option<Vec<i32>>,
716    updated_by_request: Option<&str>,
717) -> Result<crate::models::PaginatedContactAssignmentList, Error<TenancyContactAssignmentsListError>>
718{
719    let local_var_configuration = configuration;
720
721    let local_var_client = &local_var_configuration.client;
722
723    let local_var_uri_str = format!(
724        "{}/api/tenancy/contact-assignments/",
725        local_var_configuration.base_path
726    );
727    let mut local_var_req_builder =
728        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
729
730    if let Some(ref local_var_str) = contact_id {
731        local_var_req_builder = match "multi" {
732            "multi" => local_var_req_builder.query(
733                &local_var_str
734                    .into_iter()
735                    .map(|p| ("contact_id".to_owned(), p.to_string()))
736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
737            ),
738            _ => local_var_req_builder.query(&[(
739                "contact_id",
740                &local_var_str
741                    .into_iter()
742                    .map(|p| p.to_string())
743                    .collect::<Vec<String>>()
744                    .join(",")
745                    .to_string(),
746            )]),
747        };
748    }
749    if let Some(ref local_var_str) = contact_id__n {
750        local_var_req_builder = match "multi" {
751            "multi" => local_var_req_builder.query(
752                &local_var_str
753                    .into_iter()
754                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
756            ),
757            _ => local_var_req_builder.query(&[(
758                "contact_id__n",
759                &local_var_str
760                    .into_iter()
761                    .map(|p| p.to_string())
762                    .collect::<Vec<String>>()
763                    .join(",")
764                    .to_string(),
765            )]),
766        };
767    }
768    if let Some(ref local_var_str) = created {
769        local_var_req_builder = match "multi" {
770            "multi" => local_var_req_builder.query(
771                &local_var_str
772                    .into_iter()
773                    .map(|p| ("created".to_owned(), p.to_string()))
774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
775            ),
776            _ => local_var_req_builder.query(&[(
777                "created",
778                &local_var_str
779                    .into_iter()
780                    .map(|p| p.to_string())
781                    .collect::<Vec<String>>()
782                    .join(",")
783                    .to_string(),
784            )]),
785        };
786    }
787    if let Some(ref local_var_str) = created__empty {
788        local_var_req_builder = match "multi" {
789            "multi" => local_var_req_builder.query(
790                &local_var_str
791                    .into_iter()
792                    .map(|p| ("created__empty".to_owned(), p.to_string()))
793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
794            ),
795            _ => local_var_req_builder.query(&[(
796                "created__empty",
797                &local_var_str
798                    .into_iter()
799                    .map(|p| p.to_string())
800                    .collect::<Vec<String>>()
801                    .join(",")
802                    .to_string(),
803            )]),
804        };
805    }
806    if let Some(ref local_var_str) = created__gt {
807        local_var_req_builder = match "multi" {
808            "multi" => local_var_req_builder.query(
809                &local_var_str
810                    .into_iter()
811                    .map(|p| ("created__gt".to_owned(), p.to_string()))
812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
813            ),
814            _ => local_var_req_builder.query(&[(
815                "created__gt",
816                &local_var_str
817                    .into_iter()
818                    .map(|p| p.to_string())
819                    .collect::<Vec<String>>()
820                    .join(",")
821                    .to_string(),
822            )]),
823        };
824    }
825    if let Some(ref local_var_str) = created__gte {
826        local_var_req_builder = match "multi" {
827            "multi" => local_var_req_builder.query(
828                &local_var_str
829                    .into_iter()
830                    .map(|p| ("created__gte".to_owned(), p.to_string()))
831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
832            ),
833            _ => local_var_req_builder.query(&[(
834                "created__gte",
835                &local_var_str
836                    .into_iter()
837                    .map(|p| p.to_string())
838                    .collect::<Vec<String>>()
839                    .join(",")
840                    .to_string(),
841            )]),
842        };
843    }
844    if let Some(ref local_var_str) = created__lt {
845        local_var_req_builder = match "multi" {
846            "multi" => local_var_req_builder.query(
847                &local_var_str
848                    .into_iter()
849                    .map(|p| ("created__lt".to_owned(), p.to_string()))
850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
851            ),
852            _ => local_var_req_builder.query(&[(
853                "created__lt",
854                &local_var_str
855                    .into_iter()
856                    .map(|p| p.to_string())
857                    .collect::<Vec<String>>()
858                    .join(",")
859                    .to_string(),
860            )]),
861        };
862    }
863    if let Some(ref local_var_str) = created__lte {
864        local_var_req_builder = match "multi" {
865            "multi" => local_var_req_builder.query(
866                &local_var_str
867                    .into_iter()
868                    .map(|p| ("created__lte".to_owned(), p.to_string()))
869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
870            ),
871            _ => local_var_req_builder.query(&[(
872                "created__lte",
873                &local_var_str
874                    .into_iter()
875                    .map(|p| p.to_string())
876                    .collect::<Vec<String>>()
877                    .join(",")
878                    .to_string(),
879            )]),
880        };
881    }
882    if let Some(ref local_var_str) = created__n {
883        local_var_req_builder = match "multi" {
884            "multi" => local_var_req_builder.query(
885                &local_var_str
886                    .into_iter()
887                    .map(|p| ("created__n".to_owned(), p.to_string()))
888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
889            ),
890            _ => local_var_req_builder.query(&[(
891                "created__n",
892                &local_var_str
893                    .into_iter()
894                    .map(|p| p.to_string())
895                    .collect::<Vec<String>>()
896                    .join(",")
897                    .to_string(),
898            )]),
899        };
900    }
901    if let Some(ref local_var_str) = created_by_request {
902        local_var_req_builder =
903            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
904    }
905    if let Some(ref local_var_str) = group {
906        local_var_req_builder = match "multi" {
907            "multi" => local_var_req_builder.query(
908                &local_var_str
909                    .into_iter()
910                    .map(|p| ("group".to_owned(), p.to_string()))
911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
912            ),
913            _ => local_var_req_builder.query(&[(
914                "group",
915                &local_var_str
916                    .into_iter()
917                    .map(|p| p.to_string())
918                    .collect::<Vec<String>>()
919                    .join(",")
920                    .to_string(),
921            )]),
922        };
923    }
924    if let Some(ref local_var_str) = group__n {
925        local_var_req_builder = match "multi" {
926            "multi" => local_var_req_builder.query(
927                &local_var_str
928                    .into_iter()
929                    .map(|p| ("group__n".to_owned(), p.to_string()))
930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
931            ),
932            _ => local_var_req_builder.query(&[(
933                "group__n",
934                &local_var_str
935                    .into_iter()
936                    .map(|p| p.to_string())
937                    .collect::<Vec<String>>()
938                    .join(",")
939                    .to_string(),
940            )]),
941        };
942    }
943    if let Some(ref local_var_str) = group_id {
944        local_var_req_builder = match "multi" {
945            "multi" => local_var_req_builder.query(
946                &local_var_str
947                    .into_iter()
948                    .map(|p| ("group_id".to_owned(), p.to_string()))
949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
950            ),
951            _ => local_var_req_builder.query(&[(
952                "group_id",
953                &local_var_str
954                    .into_iter()
955                    .map(|p| p.to_string())
956                    .collect::<Vec<String>>()
957                    .join(",")
958                    .to_string(),
959            )]),
960        };
961    }
962    if let Some(ref local_var_str) = group_id__n {
963        local_var_req_builder = match "multi" {
964            "multi" => local_var_req_builder.query(
965                &local_var_str
966                    .into_iter()
967                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
969            ),
970            _ => local_var_req_builder.query(&[(
971                "group_id__n",
972                &local_var_str
973                    .into_iter()
974                    .map(|p| p.to_string())
975                    .collect::<Vec<String>>()
976                    .join(",")
977                    .to_string(),
978            )]),
979        };
980    }
981    if let Some(ref local_var_str) = id {
982        local_var_req_builder = match "multi" {
983            "multi" => local_var_req_builder.query(
984                &local_var_str
985                    .into_iter()
986                    .map(|p| ("id".to_owned(), p.to_string()))
987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
988            ),
989            _ => local_var_req_builder.query(&[(
990                "id",
991                &local_var_str
992                    .into_iter()
993                    .map(|p| p.to_string())
994                    .collect::<Vec<String>>()
995                    .join(",")
996                    .to_string(),
997            )]),
998        };
999    }
1000    if let Some(ref local_var_str) = id__empty {
1001        local_var_req_builder =
1002            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1003    }
1004    if let Some(ref local_var_str) = id__gt {
1005        local_var_req_builder = match "multi" {
1006            "multi" => local_var_req_builder.query(
1007                &local_var_str
1008                    .into_iter()
1009                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1011            ),
1012            _ => local_var_req_builder.query(&[(
1013                "id__gt",
1014                &local_var_str
1015                    .into_iter()
1016                    .map(|p| p.to_string())
1017                    .collect::<Vec<String>>()
1018                    .join(",")
1019                    .to_string(),
1020            )]),
1021        };
1022    }
1023    if let Some(ref local_var_str) = id__gte {
1024        local_var_req_builder = match "multi" {
1025            "multi" => local_var_req_builder.query(
1026                &local_var_str
1027                    .into_iter()
1028                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1030            ),
1031            _ => local_var_req_builder.query(&[(
1032                "id__gte",
1033                &local_var_str
1034                    .into_iter()
1035                    .map(|p| p.to_string())
1036                    .collect::<Vec<String>>()
1037                    .join(",")
1038                    .to_string(),
1039            )]),
1040        };
1041    }
1042    if let Some(ref local_var_str) = id__lt {
1043        local_var_req_builder = match "multi" {
1044            "multi" => local_var_req_builder.query(
1045                &local_var_str
1046                    .into_iter()
1047                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1049            ),
1050            _ => local_var_req_builder.query(&[(
1051                "id__lt",
1052                &local_var_str
1053                    .into_iter()
1054                    .map(|p| p.to_string())
1055                    .collect::<Vec<String>>()
1056                    .join(",")
1057                    .to_string(),
1058            )]),
1059        };
1060    }
1061    if let Some(ref local_var_str) = id__lte {
1062        local_var_req_builder = match "multi" {
1063            "multi" => local_var_req_builder.query(
1064                &local_var_str
1065                    .into_iter()
1066                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1068            ),
1069            _ => local_var_req_builder.query(&[(
1070                "id__lte",
1071                &local_var_str
1072                    .into_iter()
1073                    .map(|p| p.to_string())
1074                    .collect::<Vec<String>>()
1075                    .join(",")
1076                    .to_string(),
1077            )]),
1078        };
1079    }
1080    if let Some(ref local_var_str) = id__n {
1081        local_var_req_builder = match "multi" {
1082            "multi" => local_var_req_builder.query(
1083                &local_var_str
1084                    .into_iter()
1085                    .map(|p| ("id__n".to_owned(), p.to_string()))
1086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1087            ),
1088            _ => local_var_req_builder.query(&[(
1089                "id__n",
1090                &local_var_str
1091                    .into_iter()
1092                    .map(|p| p.to_string())
1093                    .collect::<Vec<String>>()
1094                    .join(",")
1095                    .to_string(),
1096            )]),
1097        };
1098    }
1099    if let Some(ref local_var_str) = last_updated {
1100        local_var_req_builder = match "multi" {
1101            "multi" => local_var_req_builder.query(
1102                &local_var_str
1103                    .into_iter()
1104                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1106            ),
1107            _ => local_var_req_builder.query(&[(
1108                "last_updated",
1109                &local_var_str
1110                    .into_iter()
1111                    .map(|p| p.to_string())
1112                    .collect::<Vec<String>>()
1113                    .join(",")
1114                    .to_string(),
1115            )]),
1116        };
1117    }
1118    if let Some(ref local_var_str) = last_updated__empty {
1119        local_var_req_builder = match "multi" {
1120            "multi" => local_var_req_builder.query(
1121                &local_var_str
1122                    .into_iter()
1123                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1125            ),
1126            _ => local_var_req_builder.query(&[(
1127                "last_updated__empty",
1128                &local_var_str
1129                    .into_iter()
1130                    .map(|p| p.to_string())
1131                    .collect::<Vec<String>>()
1132                    .join(",")
1133                    .to_string(),
1134            )]),
1135        };
1136    }
1137    if let Some(ref local_var_str) = last_updated__gt {
1138        local_var_req_builder = match "multi" {
1139            "multi" => local_var_req_builder.query(
1140                &local_var_str
1141                    .into_iter()
1142                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1144            ),
1145            _ => local_var_req_builder.query(&[(
1146                "last_updated__gt",
1147                &local_var_str
1148                    .into_iter()
1149                    .map(|p| p.to_string())
1150                    .collect::<Vec<String>>()
1151                    .join(",")
1152                    .to_string(),
1153            )]),
1154        };
1155    }
1156    if let Some(ref local_var_str) = last_updated__gte {
1157        local_var_req_builder = match "multi" {
1158            "multi" => local_var_req_builder.query(
1159                &local_var_str
1160                    .into_iter()
1161                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1163            ),
1164            _ => local_var_req_builder.query(&[(
1165                "last_updated__gte",
1166                &local_var_str
1167                    .into_iter()
1168                    .map(|p| p.to_string())
1169                    .collect::<Vec<String>>()
1170                    .join(",")
1171                    .to_string(),
1172            )]),
1173        };
1174    }
1175    if let Some(ref local_var_str) = last_updated__lt {
1176        local_var_req_builder = match "multi" {
1177            "multi" => local_var_req_builder.query(
1178                &local_var_str
1179                    .into_iter()
1180                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1182            ),
1183            _ => local_var_req_builder.query(&[(
1184                "last_updated__lt",
1185                &local_var_str
1186                    .into_iter()
1187                    .map(|p| p.to_string())
1188                    .collect::<Vec<String>>()
1189                    .join(",")
1190                    .to_string(),
1191            )]),
1192        };
1193    }
1194    if let Some(ref local_var_str) = last_updated__lte {
1195        local_var_req_builder = match "multi" {
1196            "multi" => local_var_req_builder.query(
1197                &local_var_str
1198                    .into_iter()
1199                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1201            ),
1202            _ => local_var_req_builder.query(&[(
1203                "last_updated__lte",
1204                &local_var_str
1205                    .into_iter()
1206                    .map(|p| p.to_string())
1207                    .collect::<Vec<String>>()
1208                    .join(",")
1209                    .to_string(),
1210            )]),
1211        };
1212    }
1213    if let Some(ref local_var_str) = last_updated__n {
1214        local_var_req_builder = match "multi" {
1215            "multi" => local_var_req_builder.query(
1216                &local_var_str
1217                    .into_iter()
1218                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1220            ),
1221            _ => local_var_req_builder.query(&[(
1222                "last_updated__n",
1223                &local_var_str
1224                    .into_iter()
1225                    .map(|p| p.to_string())
1226                    .collect::<Vec<String>>()
1227                    .join(",")
1228                    .to_string(),
1229            )]),
1230        };
1231    }
1232    if let Some(ref local_var_str) = limit {
1233        local_var_req_builder =
1234            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1235    }
1236    if let Some(ref local_var_str) = modified_by_request {
1237        local_var_req_builder =
1238            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1239    }
1240    if let Some(ref local_var_str) = object_id {
1241        local_var_req_builder = match "multi" {
1242            "multi" => local_var_req_builder.query(
1243                &local_var_str
1244                    .into_iter()
1245                    .map(|p| ("object_id".to_owned(), p.to_string()))
1246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1247            ),
1248            _ => local_var_req_builder.query(&[(
1249                "object_id",
1250                &local_var_str
1251                    .into_iter()
1252                    .map(|p| p.to_string())
1253                    .collect::<Vec<String>>()
1254                    .join(",")
1255                    .to_string(),
1256            )]),
1257        };
1258    }
1259    if let Some(ref local_var_str) = object_id__empty {
1260        local_var_req_builder =
1261            local_var_req_builder.query(&[("object_id__empty", &local_var_str.to_string())]);
1262    }
1263    if let Some(ref local_var_str) = object_id__gt {
1264        local_var_req_builder = match "multi" {
1265            "multi" => local_var_req_builder.query(
1266                &local_var_str
1267                    .into_iter()
1268                    .map(|p| ("object_id__gt".to_owned(), p.to_string()))
1269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1270            ),
1271            _ => local_var_req_builder.query(&[(
1272                "object_id__gt",
1273                &local_var_str
1274                    .into_iter()
1275                    .map(|p| p.to_string())
1276                    .collect::<Vec<String>>()
1277                    .join(",")
1278                    .to_string(),
1279            )]),
1280        };
1281    }
1282    if let Some(ref local_var_str) = object_id__gte {
1283        local_var_req_builder = match "multi" {
1284            "multi" => local_var_req_builder.query(
1285                &local_var_str
1286                    .into_iter()
1287                    .map(|p| ("object_id__gte".to_owned(), p.to_string()))
1288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1289            ),
1290            _ => local_var_req_builder.query(&[(
1291                "object_id__gte",
1292                &local_var_str
1293                    .into_iter()
1294                    .map(|p| p.to_string())
1295                    .collect::<Vec<String>>()
1296                    .join(",")
1297                    .to_string(),
1298            )]),
1299        };
1300    }
1301    if let Some(ref local_var_str) = object_id__lt {
1302        local_var_req_builder = match "multi" {
1303            "multi" => local_var_req_builder.query(
1304                &local_var_str
1305                    .into_iter()
1306                    .map(|p| ("object_id__lt".to_owned(), p.to_string()))
1307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1308            ),
1309            _ => local_var_req_builder.query(&[(
1310                "object_id__lt",
1311                &local_var_str
1312                    .into_iter()
1313                    .map(|p| p.to_string())
1314                    .collect::<Vec<String>>()
1315                    .join(",")
1316                    .to_string(),
1317            )]),
1318        };
1319    }
1320    if let Some(ref local_var_str) = object_id__lte {
1321        local_var_req_builder = match "multi" {
1322            "multi" => local_var_req_builder.query(
1323                &local_var_str
1324                    .into_iter()
1325                    .map(|p| ("object_id__lte".to_owned(), p.to_string()))
1326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1327            ),
1328            _ => local_var_req_builder.query(&[(
1329                "object_id__lte",
1330                &local_var_str
1331                    .into_iter()
1332                    .map(|p| p.to_string())
1333                    .collect::<Vec<String>>()
1334                    .join(",")
1335                    .to_string(),
1336            )]),
1337        };
1338    }
1339    if let Some(ref local_var_str) = object_id__n {
1340        local_var_req_builder = match "multi" {
1341            "multi" => local_var_req_builder.query(
1342                &local_var_str
1343                    .into_iter()
1344                    .map(|p| ("object_id__n".to_owned(), p.to_string()))
1345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1346            ),
1347            _ => local_var_req_builder.query(&[(
1348                "object_id__n",
1349                &local_var_str
1350                    .into_iter()
1351                    .map(|p| p.to_string())
1352                    .collect::<Vec<String>>()
1353                    .join(",")
1354                    .to_string(),
1355            )]),
1356        };
1357    }
1358    if let Some(ref local_var_str) = object_type {
1359        local_var_req_builder = match "multi" {
1360            "multi" => local_var_req_builder.query(
1361                &local_var_str
1362                    .into_iter()
1363                    .map(|p| ("object_type".to_owned(), p.to_string()))
1364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1365            ),
1366            _ => local_var_req_builder.query(&[(
1367                "object_type",
1368                &local_var_str
1369                    .into_iter()
1370                    .map(|p| p.to_string())
1371                    .collect::<Vec<String>>()
1372                    .join(",")
1373                    .to_string(),
1374            )]),
1375        };
1376    }
1377    if let Some(ref local_var_str) = object_type__n {
1378        local_var_req_builder = match "multi" {
1379            "multi" => local_var_req_builder.query(
1380                &local_var_str
1381                    .into_iter()
1382                    .map(|p| ("object_type__n".to_owned(), p.to_string()))
1383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1384            ),
1385            _ => local_var_req_builder.query(&[(
1386                "object_type__n",
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) = object_type_id {
1397        local_var_req_builder =
1398            local_var_req_builder.query(&[("object_type_id", &local_var_str.to_string())]);
1399    }
1400    if let Some(ref local_var_str) = object_type_id__n {
1401        local_var_req_builder =
1402            local_var_req_builder.query(&[("object_type_id__n", &local_var_str.to_string())]);
1403    }
1404    if let Some(ref local_var_str) = offset {
1405        local_var_req_builder =
1406            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1407    }
1408    if let Some(ref local_var_str) = ordering {
1409        local_var_req_builder =
1410            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1411    }
1412    if let Some(ref local_var_str) = priority {
1413        local_var_req_builder =
1414            local_var_req_builder.query(&[("priority", &local_var_str.to_string())]);
1415    }
1416    if let Some(ref local_var_str) = priority__empty {
1417        local_var_req_builder =
1418            local_var_req_builder.query(&[("priority__empty", &local_var_str.to_string())]);
1419    }
1420    if let Some(ref local_var_str) = priority__ic {
1421        local_var_req_builder = match "multi" {
1422            "multi" => local_var_req_builder.query(
1423                &local_var_str
1424                    .into_iter()
1425                    .map(|p| ("priority__ic".to_owned(), p.to_string()))
1426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1427            ),
1428            _ => local_var_req_builder.query(&[(
1429                "priority__ic",
1430                &local_var_str
1431                    .into_iter()
1432                    .map(|p| p.to_string())
1433                    .collect::<Vec<String>>()
1434                    .join(",")
1435                    .to_string(),
1436            )]),
1437        };
1438    }
1439    if let Some(ref local_var_str) = priority__ie {
1440        local_var_req_builder = match "multi" {
1441            "multi" => local_var_req_builder.query(
1442                &local_var_str
1443                    .into_iter()
1444                    .map(|p| ("priority__ie".to_owned(), p.to_string()))
1445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1446            ),
1447            _ => local_var_req_builder.query(&[(
1448                "priority__ie",
1449                &local_var_str
1450                    .into_iter()
1451                    .map(|p| p.to_string())
1452                    .collect::<Vec<String>>()
1453                    .join(",")
1454                    .to_string(),
1455            )]),
1456        };
1457    }
1458    if let Some(ref local_var_str) = priority__iew {
1459        local_var_req_builder = match "multi" {
1460            "multi" => local_var_req_builder.query(
1461                &local_var_str
1462                    .into_iter()
1463                    .map(|p| ("priority__iew".to_owned(), p.to_string()))
1464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1465            ),
1466            _ => local_var_req_builder.query(&[(
1467                "priority__iew",
1468                &local_var_str
1469                    .into_iter()
1470                    .map(|p| p.to_string())
1471                    .collect::<Vec<String>>()
1472                    .join(",")
1473                    .to_string(),
1474            )]),
1475        };
1476    }
1477    if let Some(ref local_var_str) = priority__iregex {
1478        local_var_req_builder = match "multi" {
1479            "multi" => local_var_req_builder.query(
1480                &local_var_str
1481                    .into_iter()
1482                    .map(|p| ("priority__iregex".to_owned(), p.to_string()))
1483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1484            ),
1485            _ => local_var_req_builder.query(&[(
1486                "priority__iregex",
1487                &local_var_str
1488                    .into_iter()
1489                    .map(|p| p.to_string())
1490                    .collect::<Vec<String>>()
1491                    .join(",")
1492                    .to_string(),
1493            )]),
1494        };
1495    }
1496    if let Some(ref local_var_str) = priority__isw {
1497        local_var_req_builder = match "multi" {
1498            "multi" => local_var_req_builder.query(
1499                &local_var_str
1500                    .into_iter()
1501                    .map(|p| ("priority__isw".to_owned(), p.to_string()))
1502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1503            ),
1504            _ => local_var_req_builder.query(&[(
1505                "priority__isw",
1506                &local_var_str
1507                    .into_iter()
1508                    .map(|p| p.to_string())
1509                    .collect::<Vec<String>>()
1510                    .join(",")
1511                    .to_string(),
1512            )]),
1513        };
1514    }
1515    if let Some(ref local_var_str) = priority__n {
1516        local_var_req_builder =
1517            local_var_req_builder.query(&[("priority__n", &local_var_str.to_string())]);
1518    }
1519    if let Some(ref local_var_str) = priority__nic {
1520        local_var_req_builder = match "multi" {
1521            "multi" => local_var_req_builder.query(
1522                &local_var_str
1523                    .into_iter()
1524                    .map(|p| ("priority__nic".to_owned(), p.to_string()))
1525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1526            ),
1527            _ => local_var_req_builder.query(&[(
1528                "priority__nic",
1529                &local_var_str
1530                    .into_iter()
1531                    .map(|p| p.to_string())
1532                    .collect::<Vec<String>>()
1533                    .join(",")
1534                    .to_string(),
1535            )]),
1536        };
1537    }
1538    if let Some(ref local_var_str) = priority__nie {
1539        local_var_req_builder = match "multi" {
1540            "multi" => local_var_req_builder.query(
1541                &local_var_str
1542                    .into_iter()
1543                    .map(|p| ("priority__nie".to_owned(), p.to_string()))
1544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1545            ),
1546            _ => local_var_req_builder.query(&[(
1547                "priority__nie",
1548                &local_var_str
1549                    .into_iter()
1550                    .map(|p| p.to_string())
1551                    .collect::<Vec<String>>()
1552                    .join(",")
1553                    .to_string(),
1554            )]),
1555        };
1556    }
1557    if let Some(ref local_var_str) = priority__niew {
1558        local_var_req_builder = match "multi" {
1559            "multi" => local_var_req_builder.query(
1560                &local_var_str
1561                    .into_iter()
1562                    .map(|p| ("priority__niew".to_owned(), p.to_string()))
1563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1564            ),
1565            _ => local_var_req_builder.query(&[(
1566                "priority__niew",
1567                &local_var_str
1568                    .into_iter()
1569                    .map(|p| p.to_string())
1570                    .collect::<Vec<String>>()
1571                    .join(",")
1572                    .to_string(),
1573            )]),
1574        };
1575    }
1576    if let Some(ref local_var_str) = priority__nisw {
1577        local_var_req_builder = match "multi" {
1578            "multi" => local_var_req_builder.query(
1579                &local_var_str
1580                    .into_iter()
1581                    .map(|p| ("priority__nisw".to_owned(), p.to_string()))
1582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1583            ),
1584            _ => local_var_req_builder.query(&[(
1585                "priority__nisw",
1586                &local_var_str
1587                    .into_iter()
1588                    .map(|p| p.to_string())
1589                    .collect::<Vec<String>>()
1590                    .join(",")
1591                    .to_string(),
1592            )]),
1593        };
1594    }
1595    if let Some(ref local_var_str) = priority__regex {
1596        local_var_req_builder = match "multi" {
1597            "multi" => local_var_req_builder.query(
1598                &local_var_str
1599                    .into_iter()
1600                    .map(|p| ("priority__regex".to_owned(), p.to_string()))
1601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1602            ),
1603            _ => local_var_req_builder.query(&[(
1604                "priority__regex",
1605                &local_var_str
1606                    .into_iter()
1607                    .map(|p| p.to_string())
1608                    .collect::<Vec<String>>()
1609                    .join(",")
1610                    .to_string(),
1611            )]),
1612        };
1613    }
1614    if let Some(ref local_var_str) = q {
1615        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1616    }
1617    if let Some(ref local_var_str) = role {
1618        local_var_req_builder = match "multi" {
1619            "multi" => local_var_req_builder.query(
1620                &local_var_str
1621                    .into_iter()
1622                    .map(|p| ("role".to_owned(), p.to_string()))
1623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1624            ),
1625            _ => local_var_req_builder.query(&[(
1626                "role",
1627                &local_var_str
1628                    .into_iter()
1629                    .map(|p| p.to_string())
1630                    .collect::<Vec<String>>()
1631                    .join(",")
1632                    .to_string(),
1633            )]),
1634        };
1635    }
1636    if let Some(ref local_var_str) = role__n {
1637        local_var_req_builder = match "multi" {
1638            "multi" => local_var_req_builder.query(
1639                &local_var_str
1640                    .into_iter()
1641                    .map(|p| ("role__n".to_owned(), p.to_string()))
1642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1643            ),
1644            _ => local_var_req_builder.query(&[(
1645                "role__n",
1646                &local_var_str
1647                    .into_iter()
1648                    .map(|p| p.to_string())
1649                    .collect::<Vec<String>>()
1650                    .join(",")
1651                    .to_string(),
1652            )]),
1653        };
1654    }
1655    if let Some(ref local_var_str) = role_id {
1656        local_var_req_builder = match "multi" {
1657            "multi" => local_var_req_builder.query(
1658                &local_var_str
1659                    .into_iter()
1660                    .map(|p| ("role_id".to_owned(), p.to_string()))
1661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1662            ),
1663            _ => local_var_req_builder.query(&[(
1664                "role_id",
1665                &local_var_str
1666                    .into_iter()
1667                    .map(|p| p.to_string())
1668                    .collect::<Vec<String>>()
1669                    .join(",")
1670                    .to_string(),
1671            )]),
1672        };
1673    }
1674    if let Some(ref local_var_str) = role_id__n {
1675        local_var_req_builder = match "multi" {
1676            "multi" => local_var_req_builder.query(
1677                &local_var_str
1678                    .into_iter()
1679                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
1680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1681            ),
1682            _ => local_var_req_builder.query(&[(
1683                "role_id__n",
1684                &local_var_str
1685                    .into_iter()
1686                    .map(|p| p.to_string())
1687                    .collect::<Vec<String>>()
1688                    .join(",")
1689                    .to_string(),
1690            )]),
1691        };
1692    }
1693    if let Some(ref local_var_str) = tag {
1694        local_var_req_builder = match "multi" {
1695            "multi" => local_var_req_builder.query(
1696                &local_var_str
1697                    .into_iter()
1698                    .map(|p| ("tag".to_owned(), p.to_string()))
1699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1700            ),
1701            _ => local_var_req_builder.query(&[(
1702                "tag",
1703                &local_var_str
1704                    .into_iter()
1705                    .map(|p| p.to_string())
1706                    .collect::<Vec<String>>()
1707                    .join(",")
1708                    .to_string(),
1709            )]),
1710        };
1711    }
1712    if let Some(ref local_var_str) = tag__n {
1713        local_var_req_builder = match "multi" {
1714            "multi" => local_var_req_builder.query(
1715                &local_var_str
1716                    .into_iter()
1717                    .map(|p| ("tag__n".to_owned(), p.to_string()))
1718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1719            ),
1720            _ => local_var_req_builder.query(&[(
1721                "tag__n",
1722                &local_var_str
1723                    .into_iter()
1724                    .map(|p| p.to_string())
1725                    .collect::<Vec<String>>()
1726                    .join(",")
1727                    .to_string(),
1728            )]),
1729        };
1730    }
1731    if let Some(ref local_var_str) = tag_id {
1732        local_var_req_builder = match "multi" {
1733            "multi" => local_var_req_builder.query(
1734                &local_var_str
1735                    .into_iter()
1736                    .map(|p| ("tag_id".to_owned(), p.to_string()))
1737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1738            ),
1739            _ => local_var_req_builder.query(&[(
1740                "tag_id",
1741                &local_var_str
1742                    .into_iter()
1743                    .map(|p| p.to_string())
1744                    .collect::<Vec<String>>()
1745                    .join(",")
1746                    .to_string(),
1747            )]),
1748        };
1749    }
1750    if let Some(ref local_var_str) = tag_id__n {
1751        local_var_req_builder = match "multi" {
1752            "multi" => local_var_req_builder.query(
1753                &local_var_str
1754                    .into_iter()
1755                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
1756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1757            ),
1758            _ => local_var_req_builder.query(&[(
1759                "tag_id__n",
1760                &local_var_str
1761                    .into_iter()
1762                    .map(|p| p.to_string())
1763                    .collect::<Vec<String>>()
1764                    .join(",")
1765                    .to_string(),
1766            )]),
1767        };
1768    }
1769    if let Some(ref local_var_str) = updated_by_request {
1770        local_var_req_builder =
1771            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
1772    }
1773    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1774        local_var_req_builder =
1775            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1776    }
1777    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1778        let local_var_key = local_var_apikey.key.clone();
1779        let local_var_value = match local_var_apikey.prefix {
1780            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1781            None => local_var_key,
1782        };
1783        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1784    };
1785
1786    let local_var_req = local_var_req_builder.build()?;
1787    let local_var_resp = local_var_client.execute(local_var_req).await?;
1788
1789    let local_var_status = local_var_resp.status();
1790    let local_var_content = local_var_resp.text().await?;
1791
1792    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1793        serde_json::from_str(&local_var_content).map_err(Error::from)
1794    } else {
1795        let local_var_entity: Option<TenancyContactAssignmentsListError> =
1796            serde_json::from_str(&local_var_content).ok();
1797        let local_var_error = ResponseContent {
1798            status: local_var_status,
1799            content: local_var_content,
1800            entity: local_var_entity,
1801        };
1802        Err(Error::ResponseError(local_var_error))
1803    }
1804}
1805
1806/// Patch a contact assignment object.
1807pub async fn tenancy_contact_assignments_partial_update(
1808    configuration: &configuration::Configuration,
1809    id: i32,
1810    patched_writable_contact_assignment_request: Option<
1811        crate::models::PatchedWritableContactAssignmentRequest,
1812    >,
1813) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsPartialUpdateError>> {
1814    let local_var_configuration = configuration;
1815
1816    let local_var_client = &local_var_configuration.client;
1817
1818    let local_var_uri_str = format!(
1819        "{}/api/tenancy/contact-assignments/{id}/",
1820        local_var_configuration.base_path,
1821        id = id
1822    );
1823    let mut local_var_req_builder =
1824        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1825
1826    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1827        local_var_req_builder =
1828            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1829    }
1830    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1831        let local_var_key = local_var_apikey.key.clone();
1832        let local_var_value = match local_var_apikey.prefix {
1833            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1834            None => local_var_key,
1835        };
1836        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1837    };
1838    local_var_req_builder =
1839        local_var_req_builder.json(&patched_writable_contact_assignment_request);
1840
1841    let local_var_req = local_var_req_builder.build()?;
1842    let local_var_resp = local_var_client.execute(local_var_req).await?;
1843
1844    let local_var_status = local_var_resp.status();
1845    let local_var_content = local_var_resp.text().await?;
1846
1847    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1848        serde_json::from_str(&local_var_content).map_err(Error::from)
1849    } else {
1850        let local_var_entity: Option<TenancyContactAssignmentsPartialUpdateError> =
1851            serde_json::from_str(&local_var_content).ok();
1852        let local_var_error = ResponseContent {
1853            status: local_var_status,
1854            content: local_var_content,
1855            entity: local_var_entity,
1856        };
1857        Err(Error::ResponseError(local_var_error))
1858    }
1859}
1860
1861/// Get a contact assignment object.
1862pub async fn tenancy_contact_assignments_retrieve(
1863    configuration: &configuration::Configuration,
1864    id: i32,
1865) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsRetrieveError>> {
1866    let local_var_configuration = configuration;
1867
1868    let local_var_client = &local_var_configuration.client;
1869
1870    let local_var_uri_str = format!(
1871        "{}/api/tenancy/contact-assignments/{id}/",
1872        local_var_configuration.base_path,
1873        id = id
1874    );
1875    let mut local_var_req_builder =
1876        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1877
1878    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1879        local_var_req_builder =
1880            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1881    }
1882    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1883        let local_var_key = local_var_apikey.key.clone();
1884        let local_var_value = match local_var_apikey.prefix {
1885            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1886            None => local_var_key,
1887        };
1888        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1889    };
1890
1891    let local_var_req = local_var_req_builder.build()?;
1892    let local_var_resp = local_var_client.execute(local_var_req).await?;
1893
1894    let local_var_status = local_var_resp.status();
1895    let local_var_content = local_var_resp.text().await?;
1896
1897    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1898        serde_json::from_str(&local_var_content).map_err(Error::from)
1899    } else {
1900        let local_var_entity: Option<TenancyContactAssignmentsRetrieveError> =
1901            serde_json::from_str(&local_var_content).ok();
1902        let local_var_error = ResponseContent {
1903            status: local_var_status,
1904            content: local_var_content,
1905            entity: local_var_entity,
1906        };
1907        Err(Error::ResponseError(local_var_error))
1908    }
1909}
1910
1911/// Put a contact assignment object.
1912pub async fn tenancy_contact_assignments_update(
1913    configuration: &configuration::Configuration,
1914    id: i32,
1915    writable_contact_assignment_request: crate::models::WritableContactAssignmentRequest,
1916) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsUpdateError>> {
1917    let local_var_configuration = configuration;
1918
1919    let local_var_client = &local_var_configuration.client;
1920
1921    let local_var_uri_str = format!(
1922        "{}/api/tenancy/contact-assignments/{id}/",
1923        local_var_configuration.base_path,
1924        id = id
1925    );
1926    let mut local_var_req_builder =
1927        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1928
1929    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1930        local_var_req_builder =
1931            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1932    }
1933    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1934        let local_var_key = local_var_apikey.key.clone();
1935        let local_var_value = match local_var_apikey.prefix {
1936            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1937            None => local_var_key,
1938        };
1939        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1940    };
1941    local_var_req_builder = local_var_req_builder.json(&writable_contact_assignment_request);
1942
1943    let local_var_req = local_var_req_builder.build()?;
1944    let local_var_resp = local_var_client.execute(local_var_req).await?;
1945
1946    let local_var_status = local_var_resp.status();
1947    let local_var_content = local_var_resp.text().await?;
1948
1949    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1950        serde_json::from_str(&local_var_content).map_err(Error::from)
1951    } else {
1952        let local_var_entity: Option<TenancyContactAssignmentsUpdateError> =
1953            serde_json::from_str(&local_var_content).ok();
1954        let local_var_error = ResponseContent {
1955            status: local_var_status,
1956            content: local_var_content,
1957            entity: local_var_entity,
1958        };
1959        Err(Error::ResponseError(local_var_error))
1960    }
1961}
1962
1963/// Delete a list of contact group objects.
1964pub async fn tenancy_contact_groups_bulk_destroy(
1965    configuration: &configuration::Configuration,
1966    contact_group_request: Vec<crate::models::ContactGroupRequest>,
1967) -> Result<(), Error<TenancyContactGroupsBulkDestroyError>> {
1968    let local_var_configuration = configuration;
1969
1970    let local_var_client = &local_var_configuration.client;
1971
1972    let local_var_uri_str = format!(
1973        "{}/api/tenancy/contact-groups/",
1974        local_var_configuration.base_path
1975    );
1976    let mut local_var_req_builder =
1977        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1978
1979    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1980        local_var_req_builder =
1981            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1982    }
1983    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1984        let local_var_key = local_var_apikey.key.clone();
1985        let local_var_value = match local_var_apikey.prefix {
1986            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1987            None => local_var_key,
1988        };
1989        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1990    };
1991    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
1992
1993    let local_var_req = local_var_req_builder.build()?;
1994    let local_var_resp = local_var_client.execute(local_var_req).await?;
1995
1996    let local_var_status = local_var_resp.status();
1997    let local_var_content = local_var_resp.text().await?;
1998
1999    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2000        Ok(())
2001    } else {
2002        let local_var_entity: Option<TenancyContactGroupsBulkDestroyError> =
2003            serde_json::from_str(&local_var_content).ok();
2004        let local_var_error = ResponseContent {
2005            status: local_var_status,
2006            content: local_var_content,
2007            entity: local_var_entity,
2008        };
2009        Err(Error::ResponseError(local_var_error))
2010    }
2011}
2012
2013/// Patch a list of contact group objects.
2014pub async fn tenancy_contact_groups_bulk_partial_update(
2015    configuration: &configuration::Configuration,
2016    contact_group_request: Vec<crate::models::ContactGroupRequest>,
2017) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkPartialUpdateError>> {
2018    let local_var_configuration = configuration;
2019
2020    let local_var_client = &local_var_configuration.client;
2021
2022    let local_var_uri_str = format!(
2023        "{}/api/tenancy/contact-groups/",
2024        local_var_configuration.base_path
2025    );
2026    let mut local_var_req_builder =
2027        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2028
2029    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2030        local_var_req_builder =
2031            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2032    }
2033    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2034        let local_var_key = local_var_apikey.key.clone();
2035        let local_var_value = match local_var_apikey.prefix {
2036            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2037            None => local_var_key,
2038        };
2039        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2040    };
2041    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
2042
2043    let local_var_req = local_var_req_builder.build()?;
2044    let local_var_resp = local_var_client.execute(local_var_req).await?;
2045
2046    let local_var_status = local_var_resp.status();
2047    let local_var_content = local_var_resp.text().await?;
2048
2049    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2050        serde_json::from_str(&local_var_content).map_err(Error::from)
2051    } else {
2052        let local_var_entity: Option<TenancyContactGroupsBulkPartialUpdateError> =
2053            serde_json::from_str(&local_var_content).ok();
2054        let local_var_error = ResponseContent {
2055            status: local_var_status,
2056            content: local_var_content,
2057            entity: local_var_entity,
2058        };
2059        Err(Error::ResponseError(local_var_error))
2060    }
2061}
2062
2063/// Put a list of contact group objects.
2064pub async fn tenancy_contact_groups_bulk_update(
2065    configuration: &configuration::Configuration,
2066    contact_group_request: Vec<crate::models::ContactGroupRequest>,
2067) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkUpdateError>> {
2068    let local_var_configuration = configuration;
2069
2070    let local_var_client = &local_var_configuration.client;
2071
2072    let local_var_uri_str = format!(
2073        "{}/api/tenancy/contact-groups/",
2074        local_var_configuration.base_path
2075    );
2076    let mut local_var_req_builder =
2077        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2078
2079    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2080        local_var_req_builder =
2081            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2082    }
2083    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2084        let local_var_key = local_var_apikey.key.clone();
2085        let local_var_value = match local_var_apikey.prefix {
2086            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2087            None => local_var_key,
2088        };
2089        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2090    };
2091    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
2092
2093    let local_var_req = local_var_req_builder.build()?;
2094    let local_var_resp = local_var_client.execute(local_var_req).await?;
2095
2096    let local_var_status = local_var_resp.status();
2097    let local_var_content = local_var_resp.text().await?;
2098
2099    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2100        serde_json::from_str(&local_var_content).map_err(Error::from)
2101    } else {
2102        let local_var_entity: Option<TenancyContactGroupsBulkUpdateError> =
2103            serde_json::from_str(&local_var_content).ok();
2104        let local_var_error = ResponseContent {
2105            status: local_var_status,
2106            content: local_var_content,
2107            entity: local_var_entity,
2108        };
2109        Err(Error::ResponseError(local_var_error))
2110    }
2111}
2112
2113/// Post a list of contact group objects.
2114pub async fn tenancy_contact_groups_create(
2115    configuration: &configuration::Configuration,
2116    tenancy_contact_groups_create_request: crate::models::TenancyContactGroupsCreateRequest,
2117) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsCreateError>> {
2118    let local_var_configuration = configuration;
2119
2120    let local_var_client = &local_var_configuration.client;
2121
2122    let local_var_uri_str = format!(
2123        "{}/api/tenancy/contact-groups/",
2124        local_var_configuration.base_path
2125    );
2126    let mut local_var_req_builder =
2127        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2128
2129    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2130        local_var_req_builder =
2131            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2132    }
2133    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2134        let local_var_key = local_var_apikey.key.clone();
2135        let local_var_value = match local_var_apikey.prefix {
2136            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2137            None => local_var_key,
2138        };
2139        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2140    };
2141    local_var_req_builder = local_var_req_builder.json(&tenancy_contact_groups_create_request);
2142
2143    let local_var_req = local_var_req_builder.build()?;
2144    let local_var_resp = local_var_client.execute(local_var_req).await?;
2145
2146    let local_var_status = local_var_resp.status();
2147    let local_var_content = local_var_resp.text().await?;
2148
2149    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2150        serde_json::from_str(&local_var_content).map_err(Error::from)
2151    } else {
2152        let local_var_entity: Option<TenancyContactGroupsCreateError> =
2153            serde_json::from_str(&local_var_content).ok();
2154        let local_var_error = ResponseContent {
2155            status: local_var_status,
2156            content: local_var_content,
2157            entity: local_var_entity,
2158        };
2159        Err(Error::ResponseError(local_var_error))
2160    }
2161}
2162
2163/// Delete a contact group object.
2164pub async fn tenancy_contact_groups_destroy(
2165    configuration: &configuration::Configuration,
2166    id: i32,
2167) -> Result<(), Error<TenancyContactGroupsDestroyError>> {
2168    let local_var_configuration = configuration;
2169
2170    let local_var_client = &local_var_configuration.client;
2171
2172    let local_var_uri_str = format!(
2173        "{}/api/tenancy/contact-groups/{id}/",
2174        local_var_configuration.base_path,
2175        id = id
2176    );
2177    let mut local_var_req_builder =
2178        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2179
2180    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2181        local_var_req_builder =
2182            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2183    }
2184    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2185        let local_var_key = local_var_apikey.key.clone();
2186        let local_var_value = match local_var_apikey.prefix {
2187            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2188            None => local_var_key,
2189        };
2190        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2191    };
2192
2193    let local_var_req = local_var_req_builder.build()?;
2194    let local_var_resp = local_var_client.execute(local_var_req).await?;
2195
2196    let local_var_status = local_var_resp.status();
2197    let local_var_content = local_var_resp.text().await?;
2198
2199    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2200        Ok(())
2201    } else {
2202        let local_var_entity: Option<TenancyContactGroupsDestroyError> =
2203            serde_json::from_str(&local_var_content).ok();
2204        let local_var_error = ResponseContent {
2205            status: local_var_status,
2206            content: local_var_content,
2207            entity: local_var_entity,
2208        };
2209        Err(Error::ResponseError(local_var_error))
2210    }
2211}
2212
2213/// Get a list of contact group objects.
2214pub async fn tenancy_contact_groups_list(
2215    configuration: &configuration::Configuration,
2216    ancestor: Option<Vec<String>>,
2217    ancestor__n: Option<Vec<String>>,
2218    ancestor_id: Option<Vec<String>>,
2219    ancestor_id__n: Option<Vec<String>>,
2220    contact_id: Option<Vec<i32>>,
2221    contact_id__n: Option<Vec<i32>>,
2222    created: Option<Vec<String>>,
2223    created__empty: Option<Vec<String>>,
2224    created__gt: Option<Vec<String>>,
2225    created__gte: Option<Vec<String>>,
2226    created__lt: Option<Vec<String>>,
2227    created__lte: Option<Vec<String>>,
2228    created__n: Option<Vec<String>>,
2229    created_by_request: Option<&str>,
2230    description: Option<Vec<String>>,
2231    description__empty: Option<bool>,
2232    description__ic: Option<Vec<String>>,
2233    description__ie: Option<Vec<String>>,
2234    description__iew: Option<Vec<String>>,
2235    description__iregex: Option<Vec<String>>,
2236    description__isw: Option<Vec<String>>,
2237    description__n: Option<Vec<String>>,
2238    description__nic: Option<Vec<String>>,
2239    description__nie: Option<Vec<String>>,
2240    description__niew: Option<Vec<String>>,
2241    description__nisw: Option<Vec<String>>,
2242    description__regex: Option<Vec<String>>,
2243    id: Option<Vec<i32>>,
2244    id__empty: Option<bool>,
2245    id__gt: Option<Vec<i32>>,
2246    id__gte: Option<Vec<i32>>,
2247    id__lt: Option<Vec<i32>>,
2248    id__lte: Option<Vec<i32>>,
2249    id__n: Option<Vec<i32>>,
2250    last_updated: Option<Vec<String>>,
2251    last_updated__empty: Option<Vec<String>>,
2252    last_updated__gt: Option<Vec<String>>,
2253    last_updated__gte: Option<Vec<String>>,
2254    last_updated__lt: Option<Vec<String>>,
2255    last_updated__lte: Option<Vec<String>>,
2256    last_updated__n: Option<Vec<String>>,
2257    limit: Option<i32>,
2258    modified_by_request: Option<&str>,
2259    name: Option<Vec<String>>,
2260    name__empty: Option<bool>,
2261    name__ic: Option<Vec<String>>,
2262    name__ie: Option<Vec<String>>,
2263    name__iew: Option<Vec<String>>,
2264    name__iregex: Option<Vec<String>>,
2265    name__isw: Option<Vec<String>>,
2266    name__n: Option<Vec<String>>,
2267    name__nic: Option<Vec<String>>,
2268    name__nie: Option<Vec<String>>,
2269    name__niew: Option<Vec<String>>,
2270    name__nisw: Option<Vec<String>>,
2271    name__regex: Option<Vec<String>>,
2272    offset: Option<i32>,
2273    ordering: Option<&str>,
2274    owner: Option<Vec<String>>,
2275    owner__n: Option<Vec<String>>,
2276    owner_group: Option<Vec<String>>,
2277    owner_group__n: Option<Vec<String>>,
2278    owner_group_id: Option<Vec<i32>>,
2279    owner_group_id__n: Option<Vec<i32>>,
2280    owner_id: Option<Vec<i32>>,
2281    owner_id__n: Option<Vec<i32>>,
2282    parent: Option<Vec<String>>,
2283    parent__n: Option<Vec<String>>,
2284    parent_id: Option<Vec<i32>>,
2285    parent_id__n: Option<Vec<i32>>,
2286    q: Option<&str>,
2287    slug: Option<Vec<String>>,
2288    slug__empty: Option<bool>,
2289    slug__ic: Option<Vec<String>>,
2290    slug__ie: Option<Vec<String>>,
2291    slug__iew: Option<Vec<String>>,
2292    slug__iregex: Option<Vec<String>>,
2293    slug__isw: Option<Vec<String>>,
2294    slug__n: Option<Vec<String>>,
2295    slug__nic: Option<Vec<String>>,
2296    slug__nie: Option<Vec<String>>,
2297    slug__niew: Option<Vec<String>>,
2298    slug__nisw: Option<Vec<String>>,
2299    slug__regex: Option<Vec<String>>,
2300    tag: Option<Vec<String>>,
2301    tag__n: Option<Vec<String>>,
2302    tag_id: Option<Vec<i32>>,
2303    tag_id__n: Option<Vec<i32>>,
2304    updated_by_request: Option<&str>,
2305) -> Result<crate::models::PaginatedContactGroupList, Error<TenancyContactGroupsListError>> {
2306    let local_var_configuration = configuration;
2307
2308    let local_var_client = &local_var_configuration.client;
2309
2310    let local_var_uri_str = format!(
2311        "{}/api/tenancy/contact-groups/",
2312        local_var_configuration.base_path
2313    );
2314    let mut local_var_req_builder =
2315        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2316
2317    if let Some(ref local_var_str) = ancestor {
2318        local_var_req_builder = match "multi" {
2319            "multi" => local_var_req_builder.query(
2320                &local_var_str
2321                    .into_iter()
2322                    .map(|p| ("ancestor".to_owned(), p.to_string()))
2323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2324            ),
2325            _ => local_var_req_builder.query(&[(
2326                "ancestor",
2327                &local_var_str
2328                    .into_iter()
2329                    .map(|p| p.to_string())
2330                    .collect::<Vec<String>>()
2331                    .join(",")
2332                    .to_string(),
2333            )]),
2334        };
2335    }
2336    if let Some(ref local_var_str) = ancestor__n {
2337        local_var_req_builder = match "multi" {
2338            "multi" => local_var_req_builder.query(
2339                &local_var_str
2340                    .into_iter()
2341                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
2342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2343            ),
2344            _ => local_var_req_builder.query(&[(
2345                "ancestor__n",
2346                &local_var_str
2347                    .into_iter()
2348                    .map(|p| p.to_string())
2349                    .collect::<Vec<String>>()
2350                    .join(",")
2351                    .to_string(),
2352            )]),
2353        };
2354    }
2355    if let Some(ref local_var_str) = ancestor_id {
2356        local_var_req_builder = match "multi" {
2357            "multi" => local_var_req_builder.query(
2358                &local_var_str
2359                    .into_iter()
2360                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
2361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2362            ),
2363            _ => local_var_req_builder.query(&[(
2364                "ancestor_id",
2365                &local_var_str
2366                    .into_iter()
2367                    .map(|p| p.to_string())
2368                    .collect::<Vec<String>>()
2369                    .join(",")
2370                    .to_string(),
2371            )]),
2372        };
2373    }
2374    if let Some(ref local_var_str) = ancestor_id__n {
2375        local_var_req_builder = match "multi" {
2376            "multi" => local_var_req_builder.query(
2377                &local_var_str
2378                    .into_iter()
2379                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
2380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2381            ),
2382            _ => local_var_req_builder.query(&[(
2383                "ancestor_id__n",
2384                &local_var_str
2385                    .into_iter()
2386                    .map(|p| p.to_string())
2387                    .collect::<Vec<String>>()
2388                    .join(",")
2389                    .to_string(),
2390            )]),
2391        };
2392    }
2393    if let Some(ref local_var_str) = contact_id {
2394        local_var_req_builder = match "multi" {
2395            "multi" => local_var_req_builder.query(
2396                &local_var_str
2397                    .into_iter()
2398                    .map(|p| ("contact_id".to_owned(), p.to_string()))
2399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2400            ),
2401            _ => local_var_req_builder.query(&[(
2402                "contact_id",
2403                &local_var_str
2404                    .into_iter()
2405                    .map(|p| p.to_string())
2406                    .collect::<Vec<String>>()
2407                    .join(",")
2408                    .to_string(),
2409            )]),
2410        };
2411    }
2412    if let Some(ref local_var_str) = contact_id__n {
2413        local_var_req_builder = match "multi" {
2414            "multi" => local_var_req_builder.query(
2415                &local_var_str
2416                    .into_iter()
2417                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
2418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2419            ),
2420            _ => local_var_req_builder.query(&[(
2421                "contact_id__n",
2422                &local_var_str
2423                    .into_iter()
2424                    .map(|p| p.to_string())
2425                    .collect::<Vec<String>>()
2426                    .join(",")
2427                    .to_string(),
2428            )]),
2429        };
2430    }
2431    if let Some(ref local_var_str) = created {
2432        local_var_req_builder = match "multi" {
2433            "multi" => local_var_req_builder.query(
2434                &local_var_str
2435                    .into_iter()
2436                    .map(|p| ("created".to_owned(), p.to_string()))
2437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2438            ),
2439            _ => local_var_req_builder.query(&[(
2440                "created",
2441                &local_var_str
2442                    .into_iter()
2443                    .map(|p| p.to_string())
2444                    .collect::<Vec<String>>()
2445                    .join(",")
2446                    .to_string(),
2447            )]),
2448        };
2449    }
2450    if let Some(ref local_var_str) = created__empty {
2451        local_var_req_builder = match "multi" {
2452            "multi" => local_var_req_builder.query(
2453                &local_var_str
2454                    .into_iter()
2455                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2457            ),
2458            _ => local_var_req_builder.query(&[(
2459                "created__empty",
2460                &local_var_str
2461                    .into_iter()
2462                    .map(|p| p.to_string())
2463                    .collect::<Vec<String>>()
2464                    .join(",")
2465                    .to_string(),
2466            )]),
2467        };
2468    }
2469    if let Some(ref local_var_str) = created__gt {
2470        local_var_req_builder = match "multi" {
2471            "multi" => local_var_req_builder.query(
2472                &local_var_str
2473                    .into_iter()
2474                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2476            ),
2477            _ => local_var_req_builder.query(&[(
2478                "created__gt",
2479                &local_var_str
2480                    .into_iter()
2481                    .map(|p| p.to_string())
2482                    .collect::<Vec<String>>()
2483                    .join(",")
2484                    .to_string(),
2485            )]),
2486        };
2487    }
2488    if let Some(ref local_var_str) = created__gte {
2489        local_var_req_builder = match "multi" {
2490            "multi" => local_var_req_builder.query(
2491                &local_var_str
2492                    .into_iter()
2493                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2495            ),
2496            _ => local_var_req_builder.query(&[(
2497                "created__gte",
2498                &local_var_str
2499                    .into_iter()
2500                    .map(|p| p.to_string())
2501                    .collect::<Vec<String>>()
2502                    .join(",")
2503                    .to_string(),
2504            )]),
2505        };
2506    }
2507    if let Some(ref local_var_str) = created__lt {
2508        local_var_req_builder = match "multi" {
2509            "multi" => local_var_req_builder.query(
2510                &local_var_str
2511                    .into_iter()
2512                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2514            ),
2515            _ => local_var_req_builder.query(&[(
2516                "created__lt",
2517                &local_var_str
2518                    .into_iter()
2519                    .map(|p| p.to_string())
2520                    .collect::<Vec<String>>()
2521                    .join(",")
2522                    .to_string(),
2523            )]),
2524        };
2525    }
2526    if let Some(ref local_var_str) = created__lte {
2527        local_var_req_builder = match "multi" {
2528            "multi" => local_var_req_builder.query(
2529                &local_var_str
2530                    .into_iter()
2531                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2533            ),
2534            _ => local_var_req_builder.query(&[(
2535                "created__lte",
2536                &local_var_str
2537                    .into_iter()
2538                    .map(|p| p.to_string())
2539                    .collect::<Vec<String>>()
2540                    .join(",")
2541                    .to_string(),
2542            )]),
2543        };
2544    }
2545    if let Some(ref local_var_str) = created__n {
2546        local_var_req_builder = match "multi" {
2547            "multi" => local_var_req_builder.query(
2548                &local_var_str
2549                    .into_iter()
2550                    .map(|p| ("created__n".to_owned(), p.to_string()))
2551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2552            ),
2553            _ => local_var_req_builder.query(&[(
2554                "created__n",
2555                &local_var_str
2556                    .into_iter()
2557                    .map(|p| p.to_string())
2558                    .collect::<Vec<String>>()
2559                    .join(",")
2560                    .to_string(),
2561            )]),
2562        };
2563    }
2564    if let Some(ref local_var_str) = created_by_request {
2565        local_var_req_builder =
2566            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2567    }
2568    if let Some(ref local_var_str) = description {
2569        local_var_req_builder = match "multi" {
2570            "multi" => local_var_req_builder.query(
2571                &local_var_str
2572                    .into_iter()
2573                    .map(|p| ("description".to_owned(), p.to_string()))
2574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2575            ),
2576            _ => local_var_req_builder.query(&[(
2577                "description",
2578                &local_var_str
2579                    .into_iter()
2580                    .map(|p| p.to_string())
2581                    .collect::<Vec<String>>()
2582                    .join(",")
2583                    .to_string(),
2584            )]),
2585        };
2586    }
2587    if let Some(ref local_var_str) = description__empty {
2588        local_var_req_builder =
2589            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2590    }
2591    if let Some(ref local_var_str) = description__ic {
2592        local_var_req_builder = match "multi" {
2593            "multi" => local_var_req_builder.query(
2594                &local_var_str
2595                    .into_iter()
2596                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2598            ),
2599            _ => local_var_req_builder.query(&[(
2600                "description__ic",
2601                &local_var_str
2602                    .into_iter()
2603                    .map(|p| p.to_string())
2604                    .collect::<Vec<String>>()
2605                    .join(",")
2606                    .to_string(),
2607            )]),
2608        };
2609    }
2610    if let Some(ref local_var_str) = description__ie {
2611        local_var_req_builder = match "multi" {
2612            "multi" => local_var_req_builder.query(
2613                &local_var_str
2614                    .into_iter()
2615                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2617            ),
2618            _ => local_var_req_builder.query(&[(
2619                "description__ie",
2620                &local_var_str
2621                    .into_iter()
2622                    .map(|p| p.to_string())
2623                    .collect::<Vec<String>>()
2624                    .join(",")
2625                    .to_string(),
2626            )]),
2627        };
2628    }
2629    if let Some(ref local_var_str) = description__iew {
2630        local_var_req_builder = match "multi" {
2631            "multi" => local_var_req_builder.query(
2632                &local_var_str
2633                    .into_iter()
2634                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2636            ),
2637            _ => local_var_req_builder.query(&[(
2638                "description__iew",
2639                &local_var_str
2640                    .into_iter()
2641                    .map(|p| p.to_string())
2642                    .collect::<Vec<String>>()
2643                    .join(",")
2644                    .to_string(),
2645            )]),
2646        };
2647    }
2648    if let Some(ref local_var_str) = description__iregex {
2649        local_var_req_builder = match "multi" {
2650            "multi" => local_var_req_builder.query(
2651                &local_var_str
2652                    .into_iter()
2653                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2655            ),
2656            _ => local_var_req_builder.query(&[(
2657                "description__iregex",
2658                &local_var_str
2659                    .into_iter()
2660                    .map(|p| p.to_string())
2661                    .collect::<Vec<String>>()
2662                    .join(",")
2663                    .to_string(),
2664            )]),
2665        };
2666    }
2667    if let Some(ref local_var_str) = description__isw {
2668        local_var_req_builder = match "multi" {
2669            "multi" => local_var_req_builder.query(
2670                &local_var_str
2671                    .into_iter()
2672                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2674            ),
2675            _ => local_var_req_builder.query(&[(
2676                "description__isw",
2677                &local_var_str
2678                    .into_iter()
2679                    .map(|p| p.to_string())
2680                    .collect::<Vec<String>>()
2681                    .join(",")
2682                    .to_string(),
2683            )]),
2684        };
2685    }
2686    if let Some(ref local_var_str) = description__n {
2687        local_var_req_builder = match "multi" {
2688            "multi" => local_var_req_builder.query(
2689                &local_var_str
2690                    .into_iter()
2691                    .map(|p| ("description__n".to_owned(), p.to_string()))
2692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2693            ),
2694            _ => local_var_req_builder.query(&[(
2695                "description__n",
2696                &local_var_str
2697                    .into_iter()
2698                    .map(|p| p.to_string())
2699                    .collect::<Vec<String>>()
2700                    .join(",")
2701                    .to_string(),
2702            )]),
2703        };
2704    }
2705    if let Some(ref local_var_str) = description__nic {
2706        local_var_req_builder = match "multi" {
2707            "multi" => local_var_req_builder.query(
2708                &local_var_str
2709                    .into_iter()
2710                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2712            ),
2713            _ => local_var_req_builder.query(&[(
2714                "description__nic",
2715                &local_var_str
2716                    .into_iter()
2717                    .map(|p| p.to_string())
2718                    .collect::<Vec<String>>()
2719                    .join(",")
2720                    .to_string(),
2721            )]),
2722        };
2723    }
2724    if let Some(ref local_var_str) = description__nie {
2725        local_var_req_builder = match "multi" {
2726            "multi" => local_var_req_builder.query(
2727                &local_var_str
2728                    .into_iter()
2729                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2731            ),
2732            _ => local_var_req_builder.query(&[(
2733                "description__nie",
2734                &local_var_str
2735                    .into_iter()
2736                    .map(|p| p.to_string())
2737                    .collect::<Vec<String>>()
2738                    .join(",")
2739                    .to_string(),
2740            )]),
2741        };
2742    }
2743    if let Some(ref local_var_str) = description__niew {
2744        local_var_req_builder = match "multi" {
2745            "multi" => local_var_req_builder.query(
2746                &local_var_str
2747                    .into_iter()
2748                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2750            ),
2751            _ => local_var_req_builder.query(&[(
2752                "description__niew",
2753                &local_var_str
2754                    .into_iter()
2755                    .map(|p| p.to_string())
2756                    .collect::<Vec<String>>()
2757                    .join(",")
2758                    .to_string(),
2759            )]),
2760        };
2761    }
2762    if let Some(ref local_var_str) = description__nisw {
2763        local_var_req_builder = match "multi" {
2764            "multi" => local_var_req_builder.query(
2765                &local_var_str
2766                    .into_iter()
2767                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2769            ),
2770            _ => local_var_req_builder.query(&[(
2771                "description__nisw",
2772                &local_var_str
2773                    .into_iter()
2774                    .map(|p| p.to_string())
2775                    .collect::<Vec<String>>()
2776                    .join(",")
2777                    .to_string(),
2778            )]),
2779        };
2780    }
2781    if let Some(ref local_var_str) = description__regex {
2782        local_var_req_builder = match "multi" {
2783            "multi" => local_var_req_builder.query(
2784                &local_var_str
2785                    .into_iter()
2786                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2788            ),
2789            _ => local_var_req_builder.query(&[(
2790                "description__regex",
2791                &local_var_str
2792                    .into_iter()
2793                    .map(|p| p.to_string())
2794                    .collect::<Vec<String>>()
2795                    .join(",")
2796                    .to_string(),
2797            )]),
2798        };
2799    }
2800    if let Some(ref local_var_str) = id {
2801        local_var_req_builder = match "multi" {
2802            "multi" => local_var_req_builder.query(
2803                &local_var_str
2804                    .into_iter()
2805                    .map(|p| ("id".to_owned(), p.to_string()))
2806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2807            ),
2808            _ => local_var_req_builder.query(&[(
2809                "id",
2810                &local_var_str
2811                    .into_iter()
2812                    .map(|p| p.to_string())
2813                    .collect::<Vec<String>>()
2814                    .join(",")
2815                    .to_string(),
2816            )]),
2817        };
2818    }
2819    if let Some(ref local_var_str) = id__empty {
2820        local_var_req_builder =
2821            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2822    }
2823    if let Some(ref local_var_str) = id__gt {
2824        local_var_req_builder = match "multi" {
2825            "multi" => local_var_req_builder.query(
2826                &local_var_str
2827                    .into_iter()
2828                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2830            ),
2831            _ => local_var_req_builder.query(&[(
2832                "id__gt",
2833                &local_var_str
2834                    .into_iter()
2835                    .map(|p| p.to_string())
2836                    .collect::<Vec<String>>()
2837                    .join(",")
2838                    .to_string(),
2839            )]),
2840        };
2841    }
2842    if let Some(ref local_var_str) = id__gte {
2843        local_var_req_builder = match "multi" {
2844            "multi" => local_var_req_builder.query(
2845                &local_var_str
2846                    .into_iter()
2847                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2849            ),
2850            _ => local_var_req_builder.query(&[(
2851                "id__gte",
2852                &local_var_str
2853                    .into_iter()
2854                    .map(|p| p.to_string())
2855                    .collect::<Vec<String>>()
2856                    .join(",")
2857                    .to_string(),
2858            )]),
2859        };
2860    }
2861    if let Some(ref local_var_str) = id__lt {
2862        local_var_req_builder = match "multi" {
2863            "multi" => local_var_req_builder.query(
2864                &local_var_str
2865                    .into_iter()
2866                    .map(|p| ("id__lt".to_owned(), p.to_string()))
2867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2868            ),
2869            _ => local_var_req_builder.query(&[(
2870                "id__lt",
2871                &local_var_str
2872                    .into_iter()
2873                    .map(|p| p.to_string())
2874                    .collect::<Vec<String>>()
2875                    .join(",")
2876                    .to_string(),
2877            )]),
2878        };
2879    }
2880    if let Some(ref local_var_str) = id__lte {
2881        local_var_req_builder = match "multi" {
2882            "multi" => local_var_req_builder.query(
2883                &local_var_str
2884                    .into_iter()
2885                    .map(|p| ("id__lte".to_owned(), p.to_string()))
2886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2887            ),
2888            _ => local_var_req_builder.query(&[(
2889                "id__lte",
2890                &local_var_str
2891                    .into_iter()
2892                    .map(|p| p.to_string())
2893                    .collect::<Vec<String>>()
2894                    .join(",")
2895                    .to_string(),
2896            )]),
2897        };
2898    }
2899    if let Some(ref local_var_str) = id__n {
2900        local_var_req_builder = match "multi" {
2901            "multi" => local_var_req_builder.query(
2902                &local_var_str
2903                    .into_iter()
2904                    .map(|p| ("id__n".to_owned(), p.to_string()))
2905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2906            ),
2907            _ => local_var_req_builder.query(&[(
2908                "id__n",
2909                &local_var_str
2910                    .into_iter()
2911                    .map(|p| p.to_string())
2912                    .collect::<Vec<String>>()
2913                    .join(",")
2914                    .to_string(),
2915            )]),
2916        };
2917    }
2918    if let Some(ref local_var_str) = last_updated {
2919        local_var_req_builder = match "multi" {
2920            "multi" => local_var_req_builder.query(
2921                &local_var_str
2922                    .into_iter()
2923                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2925            ),
2926            _ => local_var_req_builder.query(&[(
2927                "last_updated",
2928                &local_var_str
2929                    .into_iter()
2930                    .map(|p| p.to_string())
2931                    .collect::<Vec<String>>()
2932                    .join(",")
2933                    .to_string(),
2934            )]),
2935        };
2936    }
2937    if let Some(ref local_var_str) = last_updated__empty {
2938        local_var_req_builder = match "multi" {
2939            "multi" => local_var_req_builder.query(
2940                &local_var_str
2941                    .into_iter()
2942                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
2943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2944            ),
2945            _ => local_var_req_builder.query(&[(
2946                "last_updated__empty",
2947                &local_var_str
2948                    .into_iter()
2949                    .map(|p| p.to_string())
2950                    .collect::<Vec<String>>()
2951                    .join(",")
2952                    .to_string(),
2953            )]),
2954        };
2955    }
2956    if let Some(ref local_var_str) = last_updated__gt {
2957        local_var_req_builder = match "multi" {
2958            "multi" => local_var_req_builder.query(
2959                &local_var_str
2960                    .into_iter()
2961                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
2962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2963            ),
2964            _ => local_var_req_builder.query(&[(
2965                "last_updated__gt",
2966                &local_var_str
2967                    .into_iter()
2968                    .map(|p| p.to_string())
2969                    .collect::<Vec<String>>()
2970                    .join(",")
2971                    .to_string(),
2972            )]),
2973        };
2974    }
2975    if let Some(ref local_var_str) = last_updated__gte {
2976        local_var_req_builder = match "multi" {
2977            "multi" => local_var_req_builder.query(
2978                &local_var_str
2979                    .into_iter()
2980                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
2981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2982            ),
2983            _ => local_var_req_builder.query(&[(
2984                "last_updated__gte",
2985                &local_var_str
2986                    .into_iter()
2987                    .map(|p| p.to_string())
2988                    .collect::<Vec<String>>()
2989                    .join(",")
2990                    .to_string(),
2991            )]),
2992        };
2993    }
2994    if let Some(ref local_var_str) = last_updated__lt {
2995        local_var_req_builder = match "multi" {
2996            "multi" => local_var_req_builder.query(
2997                &local_var_str
2998                    .into_iter()
2999                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3001            ),
3002            _ => local_var_req_builder.query(&[(
3003                "last_updated__lt",
3004                &local_var_str
3005                    .into_iter()
3006                    .map(|p| p.to_string())
3007                    .collect::<Vec<String>>()
3008                    .join(",")
3009                    .to_string(),
3010            )]),
3011        };
3012    }
3013    if let Some(ref local_var_str) = last_updated__lte {
3014        local_var_req_builder = match "multi" {
3015            "multi" => local_var_req_builder.query(
3016                &local_var_str
3017                    .into_iter()
3018                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3020            ),
3021            _ => local_var_req_builder.query(&[(
3022                "last_updated__lte",
3023                &local_var_str
3024                    .into_iter()
3025                    .map(|p| p.to_string())
3026                    .collect::<Vec<String>>()
3027                    .join(",")
3028                    .to_string(),
3029            )]),
3030        };
3031    }
3032    if let Some(ref local_var_str) = last_updated__n {
3033        local_var_req_builder = match "multi" {
3034            "multi" => local_var_req_builder.query(
3035                &local_var_str
3036                    .into_iter()
3037                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3039            ),
3040            _ => local_var_req_builder.query(&[(
3041                "last_updated__n",
3042                &local_var_str
3043                    .into_iter()
3044                    .map(|p| p.to_string())
3045                    .collect::<Vec<String>>()
3046                    .join(",")
3047                    .to_string(),
3048            )]),
3049        };
3050    }
3051    if let Some(ref local_var_str) = limit {
3052        local_var_req_builder =
3053            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3054    }
3055    if let Some(ref local_var_str) = modified_by_request {
3056        local_var_req_builder =
3057            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3058    }
3059    if let Some(ref local_var_str) = name {
3060        local_var_req_builder = match "multi" {
3061            "multi" => local_var_req_builder.query(
3062                &local_var_str
3063                    .into_iter()
3064                    .map(|p| ("name".to_owned(), p.to_string()))
3065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3066            ),
3067            _ => local_var_req_builder.query(&[(
3068                "name",
3069                &local_var_str
3070                    .into_iter()
3071                    .map(|p| p.to_string())
3072                    .collect::<Vec<String>>()
3073                    .join(",")
3074                    .to_string(),
3075            )]),
3076        };
3077    }
3078    if let Some(ref local_var_str) = name__empty {
3079        local_var_req_builder =
3080            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3081    }
3082    if let Some(ref local_var_str) = name__ic {
3083        local_var_req_builder = match "multi" {
3084            "multi" => local_var_req_builder.query(
3085                &local_var_str
3086                    .into_iter()
3087                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3089            ),
3090            _ => local_var_req_builder.query(&[(
3091                "name__ic",
3092                &local_var_str
3093                    .into_iter()
3094                    .map(|p| p.to_string())
3095                    .collect::<Vec<String>>()
3096                    .join(",")
3097                    .to_string(),
3098            )]),
3099        };
3100    }
3101    if let Some(ref local_var_str) = name__ie {
3102        local_var_req_builder = match "multi" {
3103            "multi" => local_var_req_builder.query(
3104                &local_var_str
3105                    .into_iter()
3106                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3108            ),
3109            _ => local_var_req_builder.query(&[(
3110                "name__ie",
3111                &local_var_str
3112                    .into_iter()
3113                    .map(|p| p.to_string())
3114                    .collect::<Vec<String>>()
3115                    .join(",")
3116                    .to_string(),
3117            )]),
3118        };
3119    }
3120    if let Some(ref local_var_str) = name__iew {
3121        local_var_req_builder = match "multi" {
3122            "multi" => local_var_req_builder.query(
3123                &local_var_str
3124                    .into_iter()
3125                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3127            ),
3128            _ => local_var_req_builder.query(&[(
3129                "name__iew",
3130                &local_var_str
3131                    .into_iter()
3132                    .map(|p| p.to_string())
3133                    .collect::<Vec<String>>()
3134                    .join(",")
3135                    .to_string(),
3136            )]),
3137        };
3138    }
3139    if let Some(ref local_var_str) = name__iregex {
3140        local_var_req_builder = match "multi" {
3141            "multi" => local_var_req_builder.query(
3142                &local_var_str
3143                    .into_iter()
3144                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3146            ),
3147            _ => local_var_req_builder.query(&[(
3148                "name__iregex",
3149                &local_var_str
3150                    .into_iter()
3151                    .map(|p| p.to_string())
3152                    .collect::<Vec<String>>()
3153                    .join(",")
3154                    .to_string(),
3155            )]),
3156        };
3157    }
3158    if let Some(ref local_var_str) = name__isw {
3159        local_var_req_builder = match "multi" {
3160            "multi" => local_var_req_builder.query(
3161                &local_var_str
3162                    .into_iter()
3163                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3165            ),
3166            _ => local_var_req_builder.query(&[(
3167                "name__isw",
3168                &local_var_str
3169                    .into_iter()
3170                    .map(|p| p.to_string())
3171                    .collect::<Vec<String>>()
3172                    .join(",")
3173                    .to_string(),
3174            )]),
3175        };
3176    }
3177    if let Some(ref local_var_str) = name__n {
3178        local_var_req_builder = match "multi" {
3179            "multi" => local_var_req_builder.query(
3180                &local_var_str
3181                    .into_iter()
3182                    .map(|p| ("name__n".to_owned(), p.to_string()))
3183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3184            ),
3185            _ => local_var_req_builder.query(&[(
3186                "name__n",
3187                &local_var_str
3188                    .into_iter()
3189                    .map(|p| p.to_string())
3190                    .collect::<Vec<String>>()
3191                    .join(",")
3192                    .to_string(),
3193            )]),
3194        };
3195    }
3196    if let Some(ref local_var_str) = name__nic {
3197        local_var_req_builder = match "multi" {
3198            "multi" => local_var_req_builder.query(
3199                &local_var_str
3200                    .into_iter()
3201                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3203            ),
3204            _ => local_var_req_builder.query(&[(
3205                "name__nic",
3206                &local_var_str
3207                    .into_iter()
3208                    .map(|p| p.to_string())
3209                    .collect::<Vec<String>>()
3210                    .join(",")
3211                    .to_string(),
3212            )]),
3213        };
3214    }
3215    if let Some(ref local_var_str) = name__nie {
3216        local_var_req_builder = match "multi" {
3217            "multi" => local_var_req_builder.query(
3218                &local_var_str
3219                    .into_iter()
3220                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3222            ),
3223            _ => local_var_req_builder.query(&[(
3224                "name__nie",
3225                &local_var_str
3226                    .into_iter()
3227                    .map(|p| p.to_string())
3228                    .collect::<Vec<String>>()
3229                    .join(",")
3230                    .to_string(),
3231            )]),
3232        };
3233    }
3234    if let Some(ref local_var_str) = name__niew {
3235        local_var_req_builder = match "multi" {
3236            "multi" => local_var_req_builder.query(
3237                &local_var_str
3238                    .into_iter()
3239                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3241            ),
3242            _ => local_var_req_builder.query(&[(
3243                "name__niew",
3244                &local_var_str
3245                    .into_iter()
3246                    .map(|p| p.to_string())
3247                    .collect::<Vec<String>>()
3248                    .join(",")
3249                    .to_string(),
3250            )]),
3251        };
3252    }
3253    if let Some(ref local_var_str) = name__nisw {
3254        local_var_req_builder = match "multi" {
3255            "multi" => local_var_req_builder.query(
3256                &local_var_str
3257                    .into_iter()
3258                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3260            ),
3261            _ => local_var_req_builder.query(&[(
3262                "name__nisw",
3263                &local_var_str
3264                    .into_iter()
3265                    .map(|p| p.to_string())
3266                    .collect::<Vec<String>>()
3267                    .join(",")
3268                    .to_string(),
3269            )]),
3270        };
3271    }
3272    if let Some(ref local_var_str) = name__regex {
3273        local_var_req_builder = match "multi" {
3274            "multi" => local_var_req_builder.query(
3275                &local_var_str
3276                    .into_iter()
3277                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3279            ),
3280            _ => local_var_req_builder.query(&[(
3281                "name__regex",
3282                &local_var_str
3283                    .into_iter()
3284                    .map(|p| p.to_string())
3285                    .collect::<Vec<String>>()
3286                    .join(",")
3287                    .to_string(),
3288            )]),
3289        };
3290    }
3291    if let Some(ref local_var_str) = offset {
3292        local_var_req_builder =
3293            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3294    }
3295    if let Some(ref local_var_str) = ordering {
3296        local_var_req_builder =
3297            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3298    }
3299    if let Some(ref local_var_str) = owner {
3300        local_var_req_builder = match "multi" {
3301            "multi" => local_var_req_builder.query(
3302                &local_var_str
3303                    .into_iter()
3304                    .map(|p| ("owner".to_owned(), p.to_string()))
3305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3306            ),
3307            _ => local_var_req_builder.query(&[(
3308                "owner",
3309                &local_var_str
3310                    .into_iter()
3311                    .map(|p| p.to_string())
3312                    .collect::<Vec<String>>()
3313                    .join(",")
3314                    .to_string(),
3315            )]),
3316        };
3317    }
3318    if let Some(ref local_var_str) = owner__n {
3319        local_var_req_builder = match "multi" {
3320            "multi" => local_var_req_builder.query(
3321                &local_var_str
3322                    .into_iter()
3323                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3325            ),
3326            _ => local_var_req_builder.query(&[(
3327                "owner__n",
3328                &local_var_str
3329                    .into_iter()
3330                    .map(|p| p.to_string())
3331                    .collect::<Vec<String>>()
3332                    .join(",")
3333                    .to_string(),
3334            )]),
3335        };
3336    }
3337    if let Some(ref local_var_str) = owner_group {
3338        local_var_req_builder = match "multi" {
3339            "multi" => local_var_req_builder.query(
3340                &local_var_str
3341                    .into_iter()
3342                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3344            ),
3345            _ => local_var_req_builder.query(&[(
3346                "owner_group",
3347                &local_var_str
3348                    .into_iter()
3349                    .map(|p| p.to_string())
3350                    .collect::<Vec<String>>()
3351                    .join(",")
3352                    .to_string(),
3353            )]),
3354        };
3355    }
3356    if let Some(ref local_var_str) = owner_group__n {
3357        local_var_req_builder = match "multi" {
3358            "multi" => local_var_req_builder.query(
3359                &local_var_str
3360                    .into_iter()
3361                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3363            ),
3364            _ => local_var_req_builder.query(&[(
3365                "owner_group__n",
3366                &local_var_str
3367                    .into_iter()
3368                    .map(|p| p.to_string())
3369                    .collect::<Vec<String>>()
3370                    .join(",")
3371                    .to_string(),
3372            )]),
3373        };
3374    }
3375    if let Some(ref local_var_str) = owner_group_id {
3376        local_var_req_builder = match "multi" {
3377            "multi" => local_var_req_builder.query(
3378                &local_var_str
3379                    .into_iter()
3380                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3382            ),
3383            _ => local_var_req_builder.query(&[(
3384                "owner_group_id",
3385                &local_var_str
3386                    .into_iter()
3387                    .map(|p| p.to_string())
3388                    .collect::<Vec<String>>()
3389                    .join(",")
3390                    .to_string(),
3391            )]),
3392        };
3393    }
3394    if let Some(ref local_var_str) = owner_group_id__n {
3395        local_var_req_builder = match "multi" {
3396            "multi" => local_var_req_builder.query(
3397                &local_var_str
3398                    .into_iter()
3399                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3401            ),
3402            _ => local_var_req_builder.query(&[(
3403                "owner_group_id__n",
3404                &local_var_str
3405                    .into_iter()
3406                    .map(|p| p.to_string())
3407                    .collect::<Vec<String>>()
3408                    .join(",")
3409                    .to_string(),
3410            )]),
3411        };
3412    }
3413    if let Some(ref local_var_str) = owner_id {
3414        local_var_req_builder = match "multi" {
3415            "multi" => local_var_req_builder.query(
3416                &local_var_str
3417                    .into_iter()
3418                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3420            ),
3421            _ => local_var_req_builder.query(&[(
3422                "owner_id",
3423                &local_var_str
3424                    .into_iter()
3425                    .map(|p| p.to_string())
3426                    .collect::<Vec<String>>()
3427                    .join(",")
3428                    .to_string(),
3429            )]),
3430        };
3431    }
3432    if let Some(ref local_var_str) = owner_id__n {
3433        local_var_req_builder = match "multi" {
3434            "multi" => local_var_req_builder.query(
3435                &local_var_str
3436                    .into_iter()
3437                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3439            ),
3440            _ => local_var_req_builder.query(&[(
3441                "owner_id__n",
3442                &local_var_str
3443                    .into_iter()
3444                    .map(|p| p.to_string())
3445                    .collect::<Vec<String>>()
3446                    .join(",")
3447                    .to_string(),
3448            )]),
3449        };
3450    }
3451    if let Some(ref local_var_str) = parent {
3452        local_var_req_builder = match "multi" {
3453            "multi" => local_var_req_builder.query(
3454                &local_var_str
3455                    .into_iter()
3456                    .map(|p| ("parent".to_owned(), p.to_string()))
3457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3458            ),
3459            _ => local_var_req_builder.query(&[(
3460                "parent",
3461                &local_var_str
3462                    .into_iter()
3463                    .map(|p| p.to_string())
3464                    .collect::<Vec<String>>()
3465                    .join(",")
3466                    .to_string(),
3467            )]),
3468        };
3469    }
3470    if let Some(ref local_var_str) = parent__n {
3471        local_var_req_builder = match "multi" {
3472            "multi" => local_var_req_builder.query(
3473                &local_var_str
3474                    .into_iter()
3475                    .map(|p| ("parent__n".to_owned(), p.to_string()))
3476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3477            ),
3478            _ => local_var_req_builder.query(&[(
3479                "parent__n",
3480                &local_var_str
3481                    .into_iter()
3482                    .map(|p| p.to_string())
3483                    .collect::<Vec<String>>()
3484                    .join(",")
3485                    .to_string(),
3486            )]),
3487        };
3488    }
3489    if let Some(ref local_var_str) = parent_id {
3490        local_var_req_builder = match "multi" {
3491            "multi" => local_var_req_builder.query(
3492                &local_var_str
3493                    .into_iter()
3494                    .map(|p| ("parent_id".to_owned(), p.to_string()))
3495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3496            ),
3497            _ => local_var_req_builder.query(&[(
3498                "parent_id",
3499                &local_var_str
3500                    .into_iter()
3501                    .map(|p| p.to_string())
3502                    .collect::<Vec<String>>()
3503                    .join(",")
3504                    .to_string(),
3505            )]),
3506        };
3507    }
3508    if let Some(ref local_var_str) = parent_id__n {
3509        local_var_req_builder = match "multi" {
3510            "multi" => local_var_req_builder.query(
3511                &local_var_str
3512                    .into_iter()
3513                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
3514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3515            ),
3516            _ => local_var_req_builder.query(&[(
3517                "parent_id__n",
3518                &local_var_str
3519                    .into_iter()
3520                    .map(|p| p.to_string())
3521                    .collect::<Vec<String>>()
3522                    .join(",")
3523                    .to_string(),
3524            )]),
3525        };
3526    }
3527    if let Some(ref local_var_str) = q {
3528        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3529    }
3530    if let Some(ref local_var_str) = slug {
3531        local_var_req_builder = match "multi" {
3532            "multi" => local_var_req_builder.query(
3533                &local_var_str
3534                    .into_iter()
3535                    .map(|p| ("slug".to_owned(), p.to_string()))
3536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3537            ),
3538            _ => local_var_req_builder.query(&[(
3539                "slug",
3540                &local_var_str
3541                    .into_iter()
3542                    .map(|p| p.to_string())
3543                    .collect::<Vec<String>>()
3544                    .join(",")
3545                    .to_string(),
3546            )]),
3547        };
3548    }
3549    if let Some(ref local_var_str) = slug__empty {
3550        local_var_req_builder =
3551            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3552    }
3553    if let Some(ref local_var_str) = slug__ic {
3554        local_var_req_builder = match "multi" {
3555            "multi" => local_var_req_builder.query(
3556                &local_var_str
3557                    .into_iter()
3558                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3560            ),
3561            _ => local_var_req_builder.query(&[(
3562                "slug__ic",
3563                &local_var_str
3564                    .into_iter()
3565                    .map(|p| p.to_string())
3566                    .collect::<Vec<String>>()
3567                    .join(",")
3568                    .to_string(),
3569            )]),
3570        };
3571    }
3572    if let Some(ref local_var_str) = slug__ie {
3573        local_var_req_builder = match "multi" {
3574            "multi" => local_var_req_builder.query(
3575                &local_var_str
3576                    .into_iter()
3577                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3579            ),
3580            _ => local_var_req_builder.query(&[(
3581                "slug__ie",
3582                &local_var_str
3583                    .into_iter()
3584                    .map(|p| p.to_string())
3585                    .collect::<Vec<String>>()
3586                    .join(",")
3587                    .to_string(),
3588            )]),
3589        };
3590    }
3591    if let Some(ref local_var_str) = slug__iew {
3592        local_var_req_builder = match "multi" {
3593            "multi" => local_var_req_builder.query(
3594                &local_var_str
3595                    .into_iter()
3596                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3598            ),
3599            _ => local_var_req_builder.query(&[(
3600                "slug__iew",
3601                &local_var_str
3602                    .into_iter()
3603                    .map(|p| p.to_string())
3604                    .collect::<Vec<String>>()
3605                    .join(",")
3606                    .to_string(),
3607            )]),
3608        };
3609    }
3610    if let Some(ref local_var_str) = slug__iregex {
3611        local_var_req_builder = match "multi" {
3612            "multi" => local_var_req_builder.query(
3613                &local_var_str
3614                    .into_iter()
3615                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3617            ),
3618            _ => local_var_req_builder.query(&[(
3619                "slug__iregex",
3620                &local_var_str
3621                    .into_iter()
3622                    .map(|p| p.to_string())
3623                    .collect::<Vec<String>>()
3624                    .join(",")
3625                    .to_string(),
3626            )]),
3627        };
3628    }
3629    if let Some(ref local_var_str) = slug__isw {
3630        local_var_req_builder = match "multi" {
3631            "multi" => local_var_req_builder.query(
3632                &local_var_str
3633                    .into_iter()
3634                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3636            ),
3637            _ => local_var_req_builder.query(&[(
3638                "slug__isw",
3639                &local_var_str
3640                    .into_iter()
3641                    .map(|p| p.to_string())
3642                    .collect::<Vec<String>>()
3643                    .join(",")
3644                    .to_string(),
3645            )]),
3646        };
3647    }
3648    if let Some(ref local_var_str) = slug__n {
3649        local_var_req_builder = match "multi" {
3650            "multi" => local_var_req_builder.query(
3651                &local_var_str
3652                    .into_iter()
3653                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3655            ),
3656            _ => local_var_req_builder.query(&[(
3657                "slug__n",
3658                &local_var_str
3659                    .into_iter()
3660                    .map(|p| p.to_string())
3661                    .collect::<Vec<String>>()
3662                    .join(",")
3663                    .to_string(),
3664            )]),
3665        };
3666    }
3667    if let Some(ref local_var_str) = slug__nic {
3668        local_var_req_builder = match "multi" {
3669            "multi" => local_var_req_builder.query(
3670                &local_var_str
3671                    .into_iter()
3672                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3674            ),
3675            _ => local_var_req_builder.query(&[(
3676                "slug__nic",
3677                &local_var_str
3678                    .into_iter()
3679                    .map(|p| p.to_string())
3680                    .collect::<Vec<String>>()
3681                    .join(",")
3682                    .to_string(),
3683            )]),
3684        };
3685    }
3686    if let Some(ref local_var_str) = slug__nie {
3687        local_var_req_builder = match "multi" {
3688            "multi" => local_var_req_builder.query(
3689                &local_var_str
3690                    .into_iter()
3691                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3693            ),
3694            _ => local_var_req_builder.query(&[(
3695                "slug__nie",
3696                &local_var_str
3697                    .into_iter()
3698                    .map(|p| p.to_string())
3699                    .collect::<Vec<String>>()
3700                    .join(",")
3701                    .to_string(),
3702            )]),
3703        };
3704    }
3705    if let Some(ref local_var_str) = slug__niew {
3706        local_var_req_builder = match "multi" {
3707            "multi" => local_var_req_builder.query(
3708                &local_var_str
3709                    .into_iter()
3710                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3712            ),
3713            _ => local_var_req_builder.query(&[(
3714                "slug__niew",
3715                &local_var_str
3716                    .into_iter()
3717                    .map(|p| p.to_string())
3718                    .collect::<Vec<String>>()
3719                    .join(",")
3720                    .to_string(),
3721            )]),
3722        };
3723    }
3724    if let Some(ref local_var_str) = slug__nisw {
3725        local_var_req_builder = match "multi" {
3726            "multi" => local_var_req_builder.query(
3727                &local_var_str
3728                    .into_iter()
3729                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3731            ),
3732            _ => local_var_req_builder.query(&[(
3733                "slug__nisw",
3734                &local_var_str
3735                    .into_iter()
3736                    .map(|p| p.to_string())
3737                    .collect::<Vec<String>>()
3738                    .join(",")
3739                    .to_string(),
3740            )]),
3741        };
3742    }
3743    if let Some(ref local_var_str) = slug__regex {
3744        local_var_req_builder = match "multi" {
3745            "multi" => local_var_req_builder.query(
3746                &local_var_str
3747                    .into_iter()
3748                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3750            ),
3751            _ => local_var_req_builder.query(&[(
3752                "slug__regex",
3753                &local_var_str
3754                    .into_iter()
3755                    .map(|p| p.to_string())
3756                    .collect::<Vec<String>>()
3757                    .join(",")
3758                    .to_string(),
3759            )]),
3760        };
3761    }
3762    if let Some(ref local_var_str) = tag {
3763        local_var_req_builder = match "multi" {
3764            "multi" => local_var_req_builder.query(
3765                &local_var_str
3766                    .into_iter()
3767                    .map(|p| ("tag".to_owned(), p.to_string()))
3768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3769            ),
3770            _ => local_var_req_builder.query(&[(
3771                "tag",
3772                &local_var_str
3773                    .into_iter()
3774                    .map(|p| p.to_string())
3775                    .collect::<Vec<String>>()
3776                    .join(",")
3777                    .to_string(),
3778            )]),
3779        };
3780    }
3781    if let Some(ref local_var_str) = tag__n {
3782        local_var_req_builder = match "multi" {
3783            "multi" => local_var_req_builder.query(
3784                &local_var_str
3785                    .into_iter()
3786                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3788            ),
3789            _ => local_var_req_builder.query(&[(
3790                "tag__n",
3791                &local_var_str
3792                    .into_iter()
3793                    .map(|p| p.to_string())
3794                    .collect::<Vec<String>>()
3795                    .join(",")
3796                    .to_string(),
3797            )]),
3798        };
3799    }
3800    if let Some(ref local_var_str) = tag_id {
3801        local_var_req_builder = match "multi" {
3802            "multi" => local_var_req_builder.query(
3803                &local_var_str
3804                    .into_iter()
3805                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3807            ),
3808            _ => local_var_req_builder.query(&[(
3809                "tag_id",
3810                &local_var_str
3811                    .into_iter()
3812                    .map(|p| p.to_string())
3813                    .collect::<Vec<String>>()
3814                    .join(",")
3815                    .to_string(),
3816            )]),
3817        };
3818    }
3819    if let Some(ref local_var_str) = tag_id__n {
3820        local_var_req_builder = match "multi" {
3821            "multi" => local_var_req_builder.query(
3822                &local_var_str
3823                    .into_iter()
3824                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3826            ),
3827            _ => local_var_req_builder.query(&[(
3828                "tag_id__n",
3829                &local_var_str
3830                    .into_iter()
3831                    .map(|p| p.to_string())
3832                    .collect::<Vec<String>>()
3833                    .join(",")
3834                    .to_string(),
3835            )]),
3836        };
3837    }
3838    if let Some(ref local_var_str) = updated_by_request {
3839        local_var_req_builder =
3840            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
3841    }
3842    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3843        local_var_req_builder =
3844            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3845    }
3846    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3847        let local_var_key = local_var_apikey.key.clone();
3848        let local_var_value = match local_var_apikey.prefix {
3849            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3850            None => local_var_key,
3851        };
3852        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3853    };
3854
3855    let local_var_req = local_var_req_builder.build()?;
3856    let local_var_resp = local_var_client.execute(local_var_req).await?;
3857
3858    let local_var_status = local_var_resp.status();
3859    let local_var_content = local_var_resp.text().await?;
3860
3861    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3862        serde_json::from_str(&local_var_content).map_err(Error::from)
3863    } else {
3864        let local_var_entity: Option<TenancyContactGroupsListError> =
3865            serde_json::from_str(&local_var_content).ok();
3866        let local_var_error = ResponseContent {
3867            status: local_var_status,
3868            content: local_var_content,
3869            entity: local_var_entity,
3870        };
3871        Err(Error::ResponseError(local_var_error))
3872    }
3873}
3874
3875/// Patch a contact group object.
3876pub async fn tenancy_contact_groups_partial_update(
3877    configuration: &configuration::Configuration,
3878    id: i32,
3879    patched_writable_contact_group_request: Option<
3880        crate::models::PatchedWritableContactGroupRequest,
3881    >,
3882) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsPartialUpdateError>> {
3883    let local_var_configuration = configuration;
3884
3885    let local_var_client = &local_var_configuration.client;
3886
3887    let local_var_uri_str = format!(
3888        "{}/api/tenancy/contact-groups/{id}/",
3889        local_var_configuration.base_path,
3890        id = id
3891    );
3892    let mut local_var_req_builder =
3893        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3894
3895    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3896        local_var_req_builder =
3897            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3898    }
3899    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3900        let local_var_key = local_var_apikey.key.clone();
3901        let local_var_value = match local_var_apikey.prefix {
3902            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3903            None => local_var_key,
3904        };
3905        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3906    };
3907    local_var_req_builder = local_var_req_builder.json(&patched_writable_contact_group_request);
3908
3909    let local_var_req = local_var_req_builder.build()?;
3910    let local_var_resp = local_var_client.execute(local_var_req).await?;
3911
3912    let local_var_status = local_var_resp.status();
3913    let local_var_content = local_var_resp.text().await?;
3914
3915    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3916        serde_json::from_str(&local_var_content).map_err(Error::from)
3917    } else {
3918        let local_var_entity: Option<TenancyContactGroupsPartialUpdateError> =
3919            serde_json::from_str(&local_var_content).ok();
3920        let local_var_error = ResponseContent {
3921            status: local_var_status,
3922            content: local_var_content,
3923            entity: local_var_entity,
3924        };
3925        Err(Error::ResponseError(local_var_error))
3926    }
3927}
3928
3929/// Get a contact group object.
3930pub async fn tenancy_contact_groups_retrieve(
3931    configuration: &configuration::Configuration,
3932    id: i32,
3933) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsRetrieveError>> {
3934    let local_var_configuration = configuration;
3935
3936    let local_var_client = &local_var_configuration.client;
3937
3938    let local_var_uri_str = format!(
3939        "{}/api/tenancy/contact-groups/{id}/",
3940        local_var_configuration.base_path,
3941        id = id
3942    );
3943    let mut local_var_req_builder =
3944        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3945
3946    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3947        local_var_req_builder =
3948            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3949    }
3950    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3951        let local_var_key = local_var_apikey.key.clone();
3952        let local_var_value = match local_var_apikey.prefix {
3953            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3954            None => local_var_key,
3955        };
3956        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3957    };
3958
3959    let local_var_req = local_var_req_builder.build()?;
3960    let local_var_resp = local_var_client.execute(local_var_req).await?;
3961
3962    let local_var_status = local_var_resp.status();
3963    let local_var_content = local_var_resp.text().await?;
3964
3965    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3966        serde_json::from_str(&local_var_content).map_err(Error::from)
3967    } else {
3968        let local_var_entity: Option<TenancyContactGroupsRetrieveError> =
3969            serde_json::from_str(&local_var_content).ok();
3970        let local_var_error = ResponseContent {
3971            status: local_var_status,
3972            content: local_var_content,
3973            entity: local_var_entity,
3974        };
3975        Err(Error::ResponseError(local_var_error))
3976    }
3977}
3978
3979/// Put a contact group object.
3980pub async fn tenancy_contact_groups_update(
3981    configuration: &configuration::Configuration,
3982    id: i32,
3983    writable_contact_group_request: crate::models::WritableContactGroupRequest,
3984) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsUpdateError>> {
3985    let local_var_configuration = configuration;
3986
3987    let local_var_client = &local_var_configuration.client;
3988
3989    let local_var_uri_str = format!(
3990        "{}/api/tenancy/contact-groups/{id}/",
3991        local_var_configuration.base_path,
3992        id = id
3993    );
3994    let mut local_var_req_builder =
3995        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3996
3997    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3998        local_var_req_builder =
3999            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4000    }
4001    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4002        let local_var_key = local_var_apikey.key.clone();
4003        let local_var_value = match local_var_apikey.prefix {
4004            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4005            None => local_var_key,
4006        };
4007        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4008    };
4009    local_var_req_builder = local_var_req_builder.json(&writable_contact_group_request);
4010
4011    let local_var_req = local_var_req_builder.build()?;
4012    let local_var_resp = local_var_client.execute(local_var_req).await?;
4013
4014    let local_var_status = local_var_resp.status();
4015    let local_var_content = local_var_resp.text().await?;
4016
4017    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4018        serde_json::from_str(&local_var_content).map_err(Error::from)
4019    } else {
4020        let local_var_entity: Option<TenancyContactGroupsUpdateError> =
4021            serde_json::from_str(&local_var_content).ok();
4022        let local_var_error = ResponseContent {
4023            status: local_var_status,
4024            content: local_var_content,
4025            entity: local_var_entity,
4026        };
4027        Err(Error::ResponseError(local_var_error))
4028    }
4029}
4030
4031/// Delete a list of contact role objects.
4032pub async fn tenancy_contact_roles_bulk_destroy(
4033    configuration: &configuration::Configuration,
4034    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4035) -> Result<(), Error<TenancyContactRolesBulkDestroyError>> {
4036    let local_var_configuration = configuration;
4037
4038    let local_var_client = &local_var_configuration.client;
4039
4040    let local_var_uri_str = format!(
4041        "{}/api/tenancy/contact-roles/",
4042        local_var_configuration.base_path
4043    );
4044    let mut local_var_req_builder =
4045        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4046
4047    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4048        local_var_req_builder =
4049            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4050    }
4051    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4052        let local_var_key = local_var_apikey.key.clone();
4053        let local_var_value = match local_var_apikey.prefix {
4054            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4055            None => local_var_key,
4056        };
4057        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4058    };
4059    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4060
4061    let local_var_req = local_var_req_builder.build()?;
4062    let local_var_resp = local_var_client.execute(local_var_req).await?;
4063
4064    let local_var_status = local_var_resp.status();
4065    let local_var_content = local_var_resp.text().await?;
4066
4067    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4068        Ok(())
4069    } else {
4070        let local_var_entity: Option<TenancyContactRolesBulkDestroyError> =
4071            serde_json::from_str(&local_var_content).ok();
4072        let local_var_error = ResponseContent {
4073            status: local_var_status,
4074            content: local_var_content,
4075            entity: local_var_entity,
4076        };
4077        Err(Error::ResponseError(local_var_error))
4078    }
4079}
4080
4081/// Patch a list of contact role objects.
4082pub async fn tenancy_contact_roles_bulk_partial_update(
4083    configuration: &configuration::Configuration,
4084    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4085) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkPartialUpdateError>> {
4086    let local_var_configuration = configuration;
4087
4088    let local_var_client = &local_var_configuration.client;
4089
4090    let local_var_uri_str = format!(
4091        "{}/api/tenancy/contact-roles/",
4092        local_var_configuration.base_path
4093    );
4094    let mut local_var_req_builder =
4095        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4096
4097    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4098        local_var_req_builder =
4099            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4100    }
4101    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4102        let local_var_key = local_var_apikey.key.clone();
4103        let local_var_value = match local_var_apikey.prefix {
4104            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4105            None => local_var_key,
4106        };
4107        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4108    };
4109    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4110
4111    let local_var_req = local_var_req_builder.build()?;
4112    let local_var_resp = local_var_client.execute(local_var_req).await?;
4113
4114    let local_var_status = local_var_resp.status();
4115    let local_var_content = local_var_resp.text().await?;
4116
4117    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4118        serde_json::from_str(&local_var_content).map_err(Error::from)
4119    } else {
4120        let local_var_entity: Option<TenancyContactRolesBulkPartialUpdateError> =
4121            serde_json::from_str(&local_var_content).ok();
4122        let local_var_error = ResponseContent {
4123            status: local_var_status,
4124            content: local_var_content,
4125            entity: local_var_entity,
4126        };
4127        Err(Error::ResponseError(local_var_error))
4128    }
4129}
4130
4131/// Put a list of contact role objects.
4132pub async fn tenancy_contact_roles_bulk_update(
4133    configuration: &configuration::Configuration,
4134    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4135) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkUpdateError>> {
4136    let local_var_configuration = configuration;
4137
4138    let local_var_client = &local_var_configuration.client;
4139
4140    let local_var_uri_str = format!(
4141        "{}/api/tenancy/contact-roles/",
4142        local_var_configuration.base_path
4143    );
4144    let mut local_var_req_builder =
4145        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4146
4147    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4148        local_var_req_builder =
4149            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4150    }
4151    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4152        let local_var_key = local_var_apikey.key.clone();
4153        let local_var_value = match local_var_apikey.prefix {
4154            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4155            None => local_var_key,
4156        };
4157        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4158    };
4159    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4160
4161    let local_var_req = local_var_req_builder.build()?;
4162    let local_var_resp = local_var_client.execute(local_var_req).await?;
4163
4164    let local_var_status = local_var_resp.status();
4165    let local_var_content = local_var_resp.text().await?;
4166
4167    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4168        serde_json::from_str(&local_var_content).map_err(Error::from)
4169    } else {
4170        let local_var_entity: Option<TenancyContactRolesBulkUpdateError> =
4171            serde_json::from_str(&local_var_content).ok();
4172        let local_var_error = ResponseContent {
4173            status: local_var_status,
4174            content: local_var_content,
4175            entity: local_var_entity,
4176        };
4177        Err(Error::ResponseError(local_var_error))
4178    }
4179}
4180
4181/// Post a list of contact role objects.
4182pub async fn tenancy_contact_roles_create(
4183    configuration: &configuration::Configuration,
4184    tenancy_contact_roles_create_request: crate::models::TenancyContactRolesCreateRequest,
4185) -> Result<crate::models::ContactRole, Error<TenancyContactRolesCreateError>> {
4186    let local_var_configuration = configuration;
4187
4188    let local_var_client = &local_var_configuration.client;
4189
4190    let local_var_uri_str = format!(
4191        "{}/api/tenancy/contact-roles/",
4192        local_var_configuration.base_path
4193    );
4194    let mut local_var_req_builder =
4195        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4196
4197    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4198        local_var_req_builder =
4199            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4200    }
4201    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4202        let local_var_key = local_var_apikey.key.clone();
4203        let local_var_value = match local_var_apikey.prefix {
4204            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4205            None => local_var_key,
4206        };
4207        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4208    };
4209    local_var_req_builder = local_var_req_builder.json(&tenancy_contact_roles_create_request);
4210
4211    let local_var_req = local_var_req_builder.build()?;
4212    let local_var_resp = local_var_client.execute(local_var_req).await?;
4213
4214    let local_var_status = local_var_resp.status();
4215    let local_var_content = local_var_resp.text().await?;
4216
4217    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4218        serde_json::from_str(&local_var_content).map_err(Error::from)
4219    } else {
4220        let local_var_entity: Option<TenancyContactRolesCreateError> =
4221            serde_json::from_str(&local_var_content).ok();
4222        let local_var_error = ResponseContent {
4223            status: local_var_status,
4224            content: local_var_content,
4225            entity: local_var_entity,
4226        };
4227        Err(Error::ResponseError(local_var_error))
4228    }
4229}
4230
4231/// Delete a contact role object.
4232pub async fn tenancy_contact_roles_destroy(
4233    configuration: &configuration::Configuration,
4234    id: i32,
4235) -> Result<(), Error<TenancyContactRolesDestroyError>> {
4236    let local_var_configuration = configuration;
4237
4238    let local_var_client = &local_var_configuration.client;
4239
4240    let local_var_uri_str = format!(
4241        "{}/api/tenancy/contact-roles/{id}/",
4242        local_var_configuration.base_path,
4243        id = id
4244    );
4245    let mut local_var_req_builder =
4246        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4247
4248    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4249        local_var_req_builder =
4250            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4251    }
4252    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4253        let local_var_key = local_var_apikey.key.clone();
4254        let local_var_value = match local_var_apikey.prefix {
4255            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4256            None => local_var_key,
4257        };
4258        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4259    };
4260
4261    let local_var_req = local_var_req_builder.build()?;
4262    let local_var_resp = local_var_client.execute(local_var_req).await?;
4263
4264    let local_var_status = local_var_resp.status();
4265    let local_var_content = local_var_resp.text().await?;
4266
4267    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4268        Ok(())
4269    } else {
4270        let local_var_entity: Option<TenancyContactRolesDestroyError> =
4271            serde_json::from_str(&local_var_content).ok();
4272        let local_var_error = ResponseContent {
4273            status: local_var_status,
4274            content: local_var_content,
4275            entity: local_var_entity,
4276        };
4277        Err(Error::ResponseError(local_var_error))
4278    }
4279}
4280
4281/// Get a list of contact role objects.
4282pub async fn tenancy_contact_roles_list(
4283    configuration: &configuration::Configuration,
4284    created: Option<Vec<String>>,
4285    created__empty: Option<Vec<String>>,
4286    created__gt: Option<Vec<String>>,
4287    created__gte: Option<Vec<String>>,
4288    created__lt: Option<Vec<String>>,
4289    created__lte: Option<Vec<String>>,
4290    created__n: Option<Vec<String>>,
4291    created_by_request: Option<&str>,
4292    description: Option<Vec<String>>,
4293    description__empty: Option<bool>,
4294    description__ic: Option<Vec<String>>,
4295    description__ie: Option<Vec<String>>,
4296    description__iew: Option<Vec<String>>,
4297    description__iregex: Option<Vec<String>>,
4298    description__isw: Option<Vec<String>>,
4299    description__n: Option<Vec<String>>,
4300    description__nic: Option<Vec<String>>,
4301    description__nie: Option<Vec<String>>,
4302    description__niew: Option<Vec<String>>,
4303    description__nisw: Option<Vec<String>>,
4304    description__regex: Option<Vec<String>>,
4305    id: Option<Vec<i32>>,
4306    id__empty: Option<bool>,
4307    id__gt: Option<Vec<i32>>,
4308    id__gte: Option<Vec<i32>>,
4309    id__lt: Option<Vec<i32>>,
4310    id__lte: Option<Vec<i32>>,
4311    id__n: Option<Vec<i32>>,
4312    last_updated: Option<Vec<String>>,
4313    last_updated__empty: Option<Vec<String>>,
4314    last_updated__gt: Option<Vec<String>>,
4315    last_updated__gte: Option<Vec<String>>,
4316    last_updated__lt: Option<Vec<String>>,
4317    last_updated__lte: Option<Vec<String>>,
4318    last_updated__n: Option<Vec<String>>,
4319    limit: Option<i32>,
4320    modified_by_request: Option<&str>,
4321    name: Option<Vec<String>>,
4322    name__empty: Option<bool>,
4323    name__ic: Option<Vec<String>>,
4324    name__ie: Option<Vec<String>>,
4325    name__iew: Option<Vec<String>>,
4326    name__iregex: Option<Vec<String>>,
4327    name__isw: Option<Vec<String>>,
4328    name__n: Option<Vec<String>>,
4329    name__nic: Option<Vec<String>>,
4330    name__nie: Option<Vec<String>>,
4331    name__niew: Option<Vec<String>>,
4332    name__nisw: Option<Vec<String>>,
4333    name__regex: Option<Vec<String>>,
4334    offset: Option<i32>,
4335    ordering: Option<&str>,
4336    owner: Option<Vec<String>>,
4337    owner__n: Option<Vec<String>>,
4338    owner_group: Option<Vec<String>>,
4339    owner_group__n: Option<Vec<String>>,
4340    owner_group_id: Option<Vec<i32>>,
4341    owner_group_id__n: Option<Vec<i32>>,
4342    owner_id: Option<Vec<i32>>,
4343    owner_id__n: Option<Vec<i32>>,
4344    q: Option<&str>,
4345    slug: Option<Vec<String>>,
4346    slug__empty: Option<bool>,
4347    slug__ic: Option<Vec<String>>,
4348    slug__ie: Option<Vec<String>>,
4349    slug__iew: Option<Vec<String>>,
4350    slug__iregex: Option<Vec<String>>,
4351    slug__isw: Option<Vec<String>>,
4352    slug__n: Option<Vec<String>>,
4353    slug__nic: Option<Vec<String>>,
4354    slug__nie: Option<Vec<String>>,
4355    slug__niew: Option<Vec<String>>,
4356    slug__nisw: Option<Vec<String>>,
4357    slug__regex: Option<Vec<String>>,
4358    tag: Option<Vec<String>>,
4359    tag__n: Option<Vec<String>>,
4360    tag_id: Option<Vec<i32>>,
4361    tag_id__n: Option<Vec<i32>>,
4362    updated_by_request: Option<&str>,
4363) -> Result<crate::models::PaginatedContactRoleList, Error<TenancyContactRolesListError>> {
4364    let local_var_configuration = configuration;
4365
4366    let local_var_client = &local_var_configuration.client;
4367
4368    let local_var_uri_str = format!(
4369        "{}/api/tenancy/contact-roles/",
4370        local_var_configuration.base_path
4371    );
4372    let mut local_var_req_builder =
4373        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4374
4375    if let Some(ref local_var_str) = created {
4376        local_var_req_builder = match "multi" {
4377            "multi" => local_var_req_builder.query(
4378                &local_var_str
4379                    .into_iter()
4380                    .map(|p| ("created".to_owned(), p.to_string()))
4381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4382            ),
4383            _ => local_var_req_builder.query(&[(
4384                "created",
4385                &local_var_str
4386                    .into_iter()
4387                    .map(|p| p.to_string())
4388                    .collect::<Vec<String>>()
4389                    .join(",")
4390                    .to_string(),
4391            )]),
4392        };
4393    }
4394    if let Some(ref local_var_str) = created__empty {
4395        local_var_req_builder = match "multi" {
4396            "multi" => local_var_req_builder.query(
4397                &local_var_str
4398                    .into_iter()
4399                    .map(|p| ("created__empty".to_owned(), p.to_string()))
4400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4401            ),
4402            _ => local_var_req_builder.query(&[(
4403                "created__empty",
4404                &local_var_str
4405                    .into_iter()
4406                    .map(|p| p.to_string())
4407                    .collect::<Vec<String>>()
4408                    .join(",")
4409                    .to_string(),
4410            )]),
4411        };
4412    }
4413    if let Some(ref local_var_str) = created__gt {
4414        local_var_req_builder = match "multi" {
4415            "multi" => local_var_req_builder.query(
4416                &local_var_str
4417                    .into_iter()
4418                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4420            ),
4421            _ => local_var_req_builder.query(&[(
4422                "created__gt",
4423                &local_var_str
4424                    .into_iter()
4425                    .map(|p| p.to_string())
4426                    .collect::<Vec<String>>()
4427                    .join(",")
4428                    .to_string(),
4429            )]),
4430        };
4431    }
4432    if let Some(ref local_var_str) = created__gte {
4433        local_var_req_builder = match "multi" {
4434            "multi" => local_var_req_builder.query(
4435                &local_var_str
4436                    .into_iter()
4437                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4439            ),
4440            _ => local_var_req_builder.query(&[(
4441                "created__gte",
4442                &local_var_str
4443                    .into_iter()
4444                    .map(|p| p.to_string())
4445                    .collect::<Vec<String>>()
4446                    .join(",")
4447                    .to_string(),
4448            )]),
4449        };
4450    }
4451    if let Some(ref local_var_str) = created__lt {
4452        local_var_req_builder = match "multi" {
4453            "multi" => local_var_req_builder.query(
4454                &local_var_str
4455                    .into_iter()
4456                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4458            ),
4459            _ => local_var_req_builder.query(&[(
4460                "created__lt",
4461                &local_var_str
4462                    .into_iter()
4463                    .map(|p| p.to_string())
4464                    .collect::<Vec<String>>()
4465                    .join(",")
4466                    .to_string(),
4467            )]),
4468        };
4469    }
4470    if let Some(ref local_var_str) = created__lte {
4471        local_var_req_builder = match "multi" {
4472            "multi" => local_var_req_builder.query(
4473                &local_var_str
4474                    .into_iter()
4475                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4477            ),
4478            _ => local_var_req_builder.query(&[(
4479                "created__lte",
4480                &local_var_str
4481                    .into_iter()
4482                    .map(|p| p.to_string())
4483                    .collect::<Vec<String>>()
4484                    .join(",")
4485                    .to_string(),
4486            )]),
4487        };
4488    }
4489    if let Some(ref local_var_str) = created__n {
4490        local_var_req_builder = match "multi" {
4491            "multi" => local_var_req_builder.query(
4492                &local_var_str
4493                    .into_iter()
4494                    .map(|p| ("created__n".to_owned(), p.to_string()))
4495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4496            ),
4497            _ => local_var_req_builder.query(&[(
4498                "created__n",
4499                &local_var_str
4500                    .into_iter()
4501                    .map(|p| p.to_string())
4502                    .collect::<Vec<String>>()
4503                    .join(",")
4504                    .to_string(),
4505            )]),
4506        };
4507    }
4508    if let Some(ref local_var_str) = created_by_request {
4509        local_var_req_builder =
4510            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4511    }
4512    if let Some(ref local_var_str) = description {
4513        local_var_req_builder = match "multi" {
4514            "multi" => local_var_req_builder.query(
4515                &local_var_str
4516                    .into_iter()
4517                    .map(|p| ("description".to_owned(), p.to_string()))
4518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4519            ),
4520            _ => local_var_req_builder.query(&[(
4521                "description",
4522                &local_var_str
4523                    .into_iter()
4524                    .map(|p| p.to_string())
4525                    .collect::<Vec<String>>()
4526                    .join(",")
4527                    .to_string(),
4528            )]),
4529        };
4530    }
4531    if let Some(ref local_var_str) = description__empty {
4532        local_var_req_builder =
4533            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4534    }
4535    if let Some(ref local_var_str) = description__ic {
4536        local_var_req_builder = match "multi" {
4537            "multi" => local_var_req_builder.query(
4538                &local_var_str
4539                    .into_iter()
4540                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4542            ),
4543            _ => local_var_req_builder.query(&[(
4544                "description__ic",
4545                &local_var_str
4546                    .into_iter()
4547                    .map(|p| p.to_string())
4548                    .collect::<Vec<String>>()
4549                    .join(",")
4550                    .to_string(),
4551            )]),
4552        };
4553    }
4554    if let Some(ref local_var_str) = description__ie {
4555        local_var_req_builder = match "multi" {
4556            "multi" => local_var_req_builder.query(
4557                &local_var_str
4558                    .into_iter()
4559                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4561            ),
4562            _ => local_var_req_builder.query(&[(
4563                "description__ie",
4564                &local_var_str
4565                    .into_iter()
4566                    .map(|p| p.to_string())
4567                    .collect::<Vec<String>>()
4568                    .join(",")
4569                    .to_string(),
4570            )]),
4571        };
4572    }
4573    if let Some(ref local_var_str) = description__iew {
4574        local_var_req_builder = match "multi" {
4575            "multi" => local_var_req_builder.query(
4576                &local_var_str
4577                    .into_iter()
4578                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4580            ),
4581            _ => local_var_req_builder.query(&[(
4582                "description__iew",
4583                &local_var_str
4584                    .into_iter()
4585                    .map(|p| p.to_string())
4586                    .collect::<Vec<String>>()
4587                    .join(",")
4588                    .to_string(),
4589            )]),
4590        };
4591    }
4592    if let Some(ref local_var_str) = description__iregex {
4593        local_var_req_builder = match "multi" {
4594            "multi" => local_var_req_builder.query(
4595                &local_var_str
4596                    .into_iter()
4597                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4599            ),
4600            _ => local_var_req_builder.query(&[(
4601                "description__iregex",
4602                &local_var_str
4603                    .into_iter()
4604                    .map(|p| p.to_string())
4605                    .collect::<Vec<String>>()
4606                    .join(",")
4607                    .to_string(),
4608            )]),
4609        };
4610    }
4611    if let Some(ref local_var_str) = description__isw {
4612        local_var_req_builder = match "multi" {
4613            "multi" => local_var_req_builder.query(
4614                &local_var_str
4615                    .into_iter()
4616                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4618            ),
4619            _ => local_var_req_builder.query(&[(
4620                "description__isw",
4621                &local_var_str
4622                    .into_iter()
4623                    .map(|p| p.to_string())
4624                    .collect::<Vec<String>>()
4625                    .join(",")
4626                    .to_string(),
4627            )]),
4628        };
4629    }
4630    if let Some(ref local_var_str) = description__n {
4631        local_var_req_builder = match "multi" {
4632            "multi" => local_var_req_builder.query(
4633                &local_var_str
4634                    .into_iter()
4635                    .map(|p| ("description__n".to_owned(), p.to_string()))
4636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4637            ),
4638            _ => local_var_req_builder.query(&[(
4639                "description__n",
4640                &local_var_str
4641                    .into_iter()
4642                    .map(|p| p.to_string())
4643                    .collect::<Vec<String>>()
4644                    .join(",")
4645                    .to_string(),
4646            )]),
4647        };
4648    }
4649    if let Some(ref local_var_str) = description__nic {
4650        local_var_req_builder = match "multi" {
4651            "multi" => local_var_req_builder.query(
4652                &local_var_str
4653                    .into_iter()
4654                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4656            ),
4657            _ => local_var_req_builder.query(&[(
4658                "description__nic",
4659                &local_var_str
4660                    .into_iter()
4661                    .map(|p| p.to_string())
4662                    .collect::<Vec<String>>()
4663                    .join(",")
4664                    .to_string(),
4665            )]),
4666        };
4667    }
4668    if let Some(ref local_var_str) = description__nie {
4669        local_var_req_builder = match "multi" {
4670            "multi" => local_var_req_builder.query(
4671                &local_var_str
4672                    .into_iter()
4673                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4675            ),
4676            _ => local_var_req_builder.query(&[(
4677                "description__nie",
4678                &local_var_str
4679                    .into_iter()
4680                    .map(|p| p.to_string())
4681                    .collect::<Vec<String>>()
4682                    .join(",")
4683                    .to_string(),
4684            )]),
4685        };
4686    }
4687    if let Some(ref local_var_str) = description__niew {
4688        local_var_req_builder = match "multi" {
4689            "multi" => local_var_req_builder.query(
4690                &local_var_str
4691                    .into_iter()
4692                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4694            ),
4695            _ => local_var_req_builder.query(&[(
4696                "description__niew",
4697                &local_var_str
4698                    .into_iter()
4699                    .map(|p| p.to_string())
4700                    .collect::<Vec<String>>()
4701                    .join(",")
4702                    .to_string(),
4703            )]),
4704        };
4705    }
4706    if let Some(ref local_var_str) = description__nisw {
4707        local_var_req_builder = match "multi" {
4708            "multi" => local_var_req_builder.query(
4709                &local_var_str
4710                    .into_iter()
4711                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4713            ),
4714            _ => local_var_req_builder.query(&[(
4715                "description__nisw",
4716                &local_var_str
4717                    .into_iter()
4718                    .map(|p| p.to_string())
4719                    .collect::<Vec<String>>()
4720                    .join(",")
4721                    .to_string(),
4722            )]),
4723        };
4724    }
4725    if let Some(ref local_var_str) = description__regex {
4726        local_var_req_builder = match "multi" {
4727            "multi" => local_var_req_builder.query(
4728                &local_var_str
4729                    .into_iter()
4730                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4732            ),
4733            _ => local_var_req_builder.query(&[(
4734                "description__regex",
4735                &local_var_str
4736                    .into_iter()
4737                    .map(|p| p.to_string())
4738                    .collect::<Vec<String>>()
4739                    .join(",")
4740                    .to_string(),
4741            )]),
4742        };
4743    }
4744    if let Some(ref local_var_str) = id {
4745        local_var_req_builder = match "multi" {
4746            "multi" => local_var_req_builder.query(
4747                &local_var_str
4748                    .into_iter()
4749                    .map(|p| ("id".to_owned(), p.to_string()))
4750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4751            ),
4752            _ => local_var_req_builder.query(&[(
4753                "id",
4754                &local_var_str
4755                    .into_iter()
4756                    .map(|p| p.to_string())
4757                    .collect::<Vec<String>>()
4758                    .join(",")
4759                    .to_string(),
4760            )]),
4761        };
4762    }
4763    if let Some(ref local_var_str) = id__empty {
4764        local_var_req_builder =
4765            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4766    }
4767    if let Some(ref local_var_str) = id__gt {
4768        local_var_req_builder = match "multi" {
4769            "multi" => local_var_req_builder.query(
4770                &local_var_str
4771                    .into_iter()
4772                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4774            ),
4775            _ => local_var_req_builder.query(&[(
4776                "id__gt",
4777                &local_var_str
4778                    .into_iter()
4779                    .map(|p| p.to_string())
4780                    .collect::<Vec<String>>()
4781                    .join(",")
4782                    .to_string(),
4783            )]),
4784        };
4785    }
4786    if let Some(ref local_var_str) = id__gte {
4787        local_var_req_builder = match "multi" {
4788            "multi" => local_var_req_builder.query(
4789                &local_var_str
4790                    .into_iter()
4791                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4793            ),
4794            _ => local_var_req_builder.query(&[(
4795                "id__gte",
4796                &local_var_str
4797                    .into_iter()
4798                    .map(|p| p.to_string())
4799                    .collect::<Vec<String>>()
4800                    .join(",")
4801                    .to_string(),
4802            )]),
4803        };
4804    }
4805    if let Some(ref local_var_str) = id__lt {
4806        local_var_req_builder = match "multi" {
4807            "multi" => local_var_req_builder.query(
4808                &local_var_str
4809                    .into_iter()
4810                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4812            ),
4813            _ => local_var_req_builder.query(&[(
4814                "id__lt",
4815                &local_var_str
4816                    .into_iter()
4817                    .map(|p| p.to_string())
4818                    .collect::<Vec<String>>()
4819                    .join(",")
4820                    .to_string(),
4821            )]),
4822        };
4823    }
4824    if let Some(ref local_var_str) = id__lte {
4825        local_var_req_builder = match "multi" {
4826            "multi" => local_var_req_builder.query(
4827                &local_var_str
4828                    .into_iter()
4829                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4831            ),
4832            _ => local_var_req_builder.query(&[(
4833                "id__lte",
4834                &local_var_str
4835                    .into_iter()
4836                    .map(|p| p.to_string())
4837                    .collect::<Vec<String>>()
4838                    .join(",")
4839                    .to_string(),
4840            )]),
4841        };
4842    }
4843    if let Some(ref local_var_str) = id__n {
4844        local_var_req_builder = match "multi" {
4845            "multi" => local_var_req_builder.query(
4846                &local_var_str
4847                    .into_iter()
4848                    .map(|p| ("id__n".to_owned(), p.to_string()))
4849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4850            ),
4851            _ => local_var_req_builder.query(&[(
4852                "id__n",
4853                &local_var_str
4854                    .into_iter()
4855                    .map(|p| p.to_string())
4856                    .collect::<Vec<String>>()
4857                    .join(",")
4858                    .to_string(),
4859            )]),
4860        };
4861    }
4862    if let Some(ref local_var_str) = last_updated {
4863        local_var_req_builder = match "multi" {
4864            "multi" => local_var_req_builder.query(
4865                &local_var_str
4866                    .into_iter()
4867                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4869            ),
4870            _ => local_var_req_builder.query(&[(
4871                "last_updated",
4872                &local_var_str
4873                    .into_iter()
4874                    .map(|p| p.to_string())
4875                    .collect::<Vec<String>>()
4876                    .join(",")
4877                    .to_string(),
4878            )]),
4879        };
4880    }
4881    if let Some(ref local_var_str) = last_updated__empty {
4882        local_var_req_builder = match "multi" {
4883            "multi" => local_var_req_builder.query(
4884                &local_var_str
4885                    .into_iter()
4886                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4888            ),
4889            _ => local_var_req_builder.query(&[(
4890                "last_updated__empty",
4891                &local_var_str
4892                    .into_iter()
4893                    .map(|p| p.to_string())
4894                    .collect::<Vec<String>>()
4895                    .join(",")
4896                    .to_string(),
4897            )]),
4898        };
4899    }
4900    if let Some(ref local_var_str) = last_updated__gt {
4901        local_var_req_builder = match "multi" {
4902            "multi" => local_var_req_builder.query(
4903                &local_var_str
4904                    .into_iter()
4905                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4907            ),
4908            _ => local_var_req_builder.query(&[(
4909                "last_updated__gt",
4910                &local_var_str
4911                    .into_iter()
4912                    .map(|p| p.to_string())
4913                    .collect::<Vec<String>>()
4914                    .join(",")
4915                    .to_string(),
4916            )]),
4917        };
4918    }
4919    if let Some(ref local_var_str) = last_updated__gte {
4920        local_var_req_builder = match "multi" {
4921            "multi" => local_var_req_builder.query(
4922                &local_var_str
4923                    .into_iter()
4924                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4926            ),
4927            _ => local_var_req_builder.query(&[(
4928                "last_updated__gte",
4929                &local_var_str
4930                    .into_iter()
4931                    .map(|p| p.to_string())
4932                    .collect::<Vec<String>>()
4933                    .join(",")
4934                    .to_string(),
4935            )]),
4936        };
4937    }
4938    if let Some(ref local_var_str) = last_updated__lt {
4939        local_var_req_builder = match "multi" {
4940            "multi" => local_var_req_builder.query(
4941                &local_var_str
4942                    .into_iter()
4943                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4945            ),
4946            _ => local_var_req_builder.query(&[(
4947                "last_updated__lt",
4948                &local_var_str
4949                    .into_iter()
4950                    .map(|p| p.to_string())
4951                    .collect::<Vec<String>>()
4952                    .join(",")
4953                    .to_string(),
4954            )]),
4955        };
4956    }
4957    if let Some(ref local_var_str) = last_updated__lte {
4958        local_var_req_builder = match "multi" {
4959            "multi" => local_var_req_builder.query(
4960                &local_var_str
4961                    .into_iter()
4962                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4964            ),
4965            _ => local_var_req_builder.query(&[(
4966                "last_updated__lte",
4967                &local_var_str
4968                    .into_iter()
4969                    .map(|p| p.to_string())
4970                    .collect::<Vec<String>>()
4971                    .join(",")
4972                    .to_string(),
4973            )]),
4974        };
4975    }
4976    if let Some(ref local_var_str) = last_updated__n {
4977        local_var_req_builder = match "multi" {
4978            "multi" => local_var_req_builder.query(
4979                &local_var_str
4980                    .into_iter()
4981                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4983            ),
4984            _ => local_var_req_builder.query(&[(
4985                "last_updated__n",
4986                &local_var_str
4987                    .into_iter()
4988                    .map(|p| p.to_string())
4989                    .collect::<Vec<String>>()
4990                    .join(",")
4991                    .to_string(),
4992            )]),
4993        };
4994    }
4995    if let Some(ref local_var_str) = limit {
4996        local_var_req_builder =
4997            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4998    }
4999    if let Some(ref local_var_str) = modified_by_request {
5000        local_var_req_builder =
5001            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5002    }
5003    if let Some(ref local_var_str) = name {
5004        local_var_req_builder = match "multi" {
5005            "multi" => local_var_req_builder.query(
5006                &local_var_str
5007                    .into_iter()
5008                    .map(|p| ("name".to_owned(), p.to_string()))
5009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5010            ),
5011            _ => local_var_req_builder.query(&[(
5012                "name",
5013                &local_var_str
5014                    .into_iter()
5015                    .map(|p| p.to_string())
5016                    .collect::<Vec<String>>()
5017                    .join(",")
5018                    .to_string(),
5019            )]),
5020        };
5021    }
5022    if let Some(ref local_var_str) = name__empty {
5023        local_var_req_builder =
5024            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5025    }
5026    if let Some(ref local_var_str) = name__ic {
5027        local_var_req_builder = match "multi" {
5028            "multi" => local_var_req_builder.query(
5029                &local_var_str
5030                    .into_iter()
5031                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5033            ),
5034            _ => local_var_req_builder.query(&[(
5035                "name__ic",
5036                &local_var_str
5037                    .into_iter()
5038                    .map(|p| p.to_string())
5039                    .collect::<Vec<String>>()
5040                    .join(",")
5041                    .to_string(),
5042            )]),
5043        };
5044    }
5045    if let Some(ref local_var_str) = name__ie {
5046        local_var_req_builder = match "multi" {
5047            "multi" => local_var_req_builder.query(
5048                &local_var_str
5049                    .into_iter()
5050                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5052            ),
5053            _ => local_var_req_builder.query(&[(
5054                "name__ie",
5055                &local_var_str
5056                    .into_iter()
5057                    .map(|p| p.to_string())
5058                    .collect::<Vec<String>>()
5059                    .join(",")
5060                    .to_string(),
5061            )]),
5062        };
5063    }
5064    if let Some(ref local_var_str) = name__iew {
5065        local_var_req_builder = match "multi" {
5066            "multi" => local_var_req_builder.query(
5067                &local_var_str
5068                    .into_iter()
5069                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5071            ),
5072            _ => local_var_req_builder.query(&[(
5073                "name__iew",
5074                &local_var_str
5075                    .into_iter()
5076                    .map(|p| p.to_string())
5077                    .collect::<Vec<String>>()
5078                    .join(",")
5079                    .to_string(),
5080            )]),
5081        };
5082    }
5083    if let Some(ref local_var_str) = name__iregex {
5084        local_var_req_builder = match "multi" {
5085            "multi" => local_var_req_builder.query(
5086                &local_var_str
5087                    .into_iter()
5088                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5090            ),
5091            _ => local_var_req_builder.query(&[(
5092                "name__iregex",
5093                &local_var_str
5094                    .into_iter()
5095                    .map(|p| p.to_string())
5096                    .collect::<Vec<String>>()
5097                    .join(",")
5098                    .to_string(),
5099            )]),
5100        };
5101    }
5102    if let Some(ref local_var_str) = name__isw {
5103        local_var_req_builder = match "multi" {
5104            "multi" => local_var_req_builder.query(
5105                &local_var_str
5106                    .into_iter()
5107                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5109            ),
5110            _ => local_var_req_builder.query(&[(
5111                "name__isw",
5112                &local_var_str
5113                    .into_iter()
5114                    .map(|p| p.to_string())
5115                    .collect::<Vec<String>>()
5116                    .join(",")
5117                    .to_string(),
5118            )]),
5119        };
5120    }
5121    if let Some(ref local_var_str) = name__n {
5122        local_var_req_builder = match "multi" {
5123            "multi" => local_var_req_builder.query(
5124                &local_var_str
5125                    .into_iter()
5126                    .map(|p| ("name__n".to_owned(), p.to_string()))
5127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5128            ),
5129            _ => local_var_req_builder.query(&[(
5130                "name__n",
5131                &local_var_str
5132                    .into_iter()
5133                    .map(|p| p.to_string())
5134                    .collect::<Vec<String>>()
5135                    .join(",")
5136                    .to_string(),
5137            )]),
5138        };
5139    }
5140    if let Some(ref local_var_str) = name__nic {
5141        local_var_req_builder = match "multi" {
5142            "multi" => local_var_req_builder.query(
5143                &local_var_str
5144                    .into_iter()
5145                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5147            ),
5148            _ => local_var_req_builder.query(&[(
5149                "name__nic",
5150                &local_var_str
5151                    .into_iter()
5152                    .map(|p| p.to_string())
5153                    .collect::<Vec<String>>()
5154                    .join(",")
5155                    .to_string(),
5156            )]),
5157        };
5158    }
5159    if let Some(ref local_var_str) = name__nie {
5160        local_var_req_builder = match "multi" {
5161            "multi" => local_var_req_builder.query(
5162                &local_var_str
5163                    .into_iter()
5164                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5166            ),
5167            _ => local_var_req_builder.query(&[(
5168                "name__nie",
5169                &local_var_str
5170                    .into_iter()
5171                    .map(|p| p.to_string())
5172                    .collect::<Vec<String>>()
5173                    .join(",")
5174                    .to_string(),
5175            )]),
5176        };
5177    }
5178    if let Some(ref local_var_str) = name__niew {
5179        local_var_req_builder = match "multi" {
5180            "multi" => local_var_req_builder.query(
5181                &local_var_str
5182                    .into_iter()
5183                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5185            ),
5186            _ => local_var_req_builder.query(&[(
5187                "name__niew",
5188                &local_var_str
5189                    .into_iter()
5190                    .map(|p| p.to_string())
5191                    .collect::<Vec<String>>()
5192                    .join(",")
5193                    .to_string(),
5194            )]),
5195        };
5196    }
5197    if let Some(ref local_var_str) = name__nisw {
5198        local_var_req_builder = match "multi" {
5199            "multi" => local_var_req_builder.query(
5200                &local_var_str
5201                    .into_iter()
5202                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5204            ),
5205            _ => local_var_req_builder.query(&[(
5206                "name__nisw",
5207                &local_var_str
5208                    .into_iter()
5209                    .map(|p| p.to_string())
5210                    .collect::<Vec<String>>()
5211                    .join(",")
5212                    .to_string(),
5213            )]),
5214        };
5215    }
5216    if let Some(ref local_var_str) = name__regex {
5217        local_var_req_builder = match "multi" {
5218            "multi" => local_var_req_builder.query(
5219                &local_var_str
5220                    .into_iter()
5221                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5223            ),
5224            _ => local_var_req_builder.query(&[(
5225                "name__regex",
5226                &local_var_str
5227                    .into_iter()
5228                    .map(|p| p.to_string())
5229                    .collect::<Vec<String>>()
5230                    .join(",")
5231                    .to_string(),
5232            )]),
5233        };
5234    }
5235    if let Some(ref local_var_str) = offset {
5236        local_var_req_builder =
5237            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5238    }
5239    if let Some(ref local_var_str) = ordering {
5240        local_var_req_builder =
5241            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5242    }
5243    if let Some(ref local_var_str) = owner {
5244        local_var_req_builder = match "multi" {
5245            "multi" => local_var_req_builder.query(
5246                &local_var_str
5247                    .into_iter()
5248                    .map(|p| ("owner".to_owned(), p.to_string()))
5249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5250            ),
5251            _ => local_var_req_builder.query(&[(
5252                "owner",
5253                &local_var_str
5254                    .into_iter()
5255                    .map(|p| p.to_string())
5256                    .collect::<Vec<String>>()
5257                    .join(",")
5258                    .to_string(),
5259            )]),
5260        };
5261    }
5262    if let Some(ref local_var_str) = owner__n {
5263        local_var_req_builder = match "multi" {
5264            "multi" => local_var_req_builder.query(
5265                &local_var_str
5266                    .into_iter()
5267                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5269            ),
5270            _ => local_var_req_builder.query(&[(
5271                "owner__n",
5272                &local_var_str
5273                    .into_iter()
5274                    .map(|p| p.to_string())
5275                    .collect::<Vec<String>>()
5276                    .join(",")
5277                    .to_string(),
5278            )]),
5279        };
5280    }
5281    if let Some(ref local_var_str) = owner_group {
5282        local_var_req_builder = match "multi" {
5283            "multi" => local_var_req_builder.query(
5284                &local_var_str
5285                    .into_iter()
5286                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5288            ),
5289            _ => local_var_req_builder.query(&[(
5290                "owner_group",
5291                &local_var_str
5292                    .into_iter()
5293                    .map(|p| p.to_string())
5294                    .collect::<Vec<String>>()
5295                    .join(",")
5296                    .to_string(),
5297            )]),
5298        };
5299    }
5300    if let Some(ref local_var_str) = owner_group__n {
5301        local_var_req_builder = match "multi" {
5302            "multi" => local_var_req_builder.query(
5303                &local_var_str
5304                    .into_iter()
5305                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5307            ),
5308            _ => local_var_req_builder.query(&[(
5309                "owner_group__n",
5310                &local_var_str
5311                    .into_iter()
5312                    .map(|p| p.to_string())
5313                    .collect::<Vec<String>>()
5314                    .join(",")
5315                    .to_string(),
5316            )]),
5317        };
5318    }
5319    if let Some(ref local_var_str) = owner_group_id {
5320        local_var_req_builder = match "multi" {
5321            "multi" => local_var_req_builder.query(
5322                &local_var_str
5323                    .into_iter()
5324                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5326            ),
5327            _ => local_var_req_builder.query(&[(
5328                "owner_group_id",
5329                &local_var_str
5330                    .into_iter()
5331                    .map(|p| p.to_string())
5332                    .collect::<Vec<String>>()
5333                    .join(",")
5334                    .to_string(),
5335            )]),
5336        };
5337    }
5338    if let Some(ref local_var_str) = owner_group_id__n {
5339        local_var_req_builder = match "multi" {
5340            "multi" => local_var_req_builder.query(
5341                &local_var_str
5342                    .into_iter()
5343                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5345            ),
5346            _ => local_var_req_builder.query(&[(
5347                "owner_group_id__n",
5348                &local_var_str
5349                    .into_iter()
5350                    .map(|p| p.to_string())
5351                    .collect::<Vec<String>>()
5352                    .join(",")
5353                    .to_string(),
5354            )]),
5355        };
5356    }
5357    if let Some(ref local_var_str) = owner_id {
5358        local_var_req_builder = match "multi" {
5359            "multi" => local_var_req_builder.query(
5360                &local_var_str
5361                    .into_iter()
5362                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5364            ),
5365            _ => local_var_req_builder.query(&[(
5366                "owner_id",
5367                &local_var_str
5368                    .into_iter()
5369                    .map(|p| p.to_string())
5370                    .collect::<Vec<String>>()
5371                    .join(",")
5372                    .to_string(),
5373            )]),
5374        };
5375    }
5376    if let Some(ref local_var_str) = owner_id__n {
5377        local_var_req_builder = match "multi" {
5378            "multi" => local_var_req_builder.query(
5379                &local_var_str
5380                    .into_iter()
5381                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5383            ),
5384            _ => local_var_req_builder.query(&[(
5385                "owner_id__n",
5386                &local_var_str
5387                    .into_iter()
5388                    .map(|p| p.to_string())
5389                    .collect::<Vec<String>>()
5390                    .join(",")
5391                    .to_string(),
5392            )]),
5393        };
5394    }
5395    if let Some(ref local_var_str) = q {
5396        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5397    }
5398    if let Some(ref local_var_str) = slug {
5399        local_var_req_builder = match "multi" {
5400            "multi" => local_var_req_builder.query(
5401                &local_var_str
5402                    .into_iter()
5403                    .map(|p| ("slug".to_owned(), p.to_string()))
5404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5405            ),
5406            _ => local_var_req_builder.query(&[(
5407                "slug",
5408                &local_var_str
5409                    .into_iter()
5410                    .map(|p| p.to_string())
5411                    .collect::<Vec<String>>()
5412                    .join(",")
5413                    .to_string(),
5414            )]),
5415        };
5416    }
5417    if let Some(ref local_var_str) = slug__empty {
5418        local_var_req_builder =
5419            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
5420    }
5421    if let Some(ref local_var_str) = slug__ic {
5422        local_var_req_builder = match "multi" {
5423            "multi" => local_var_req_builder.query(
5424                &local_var_str
5425                    .into_iter()
5426                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
5427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5428            ),
5429            _ => local_var_req_builder.query(&[(
5430                "slug__ic",
5431                &local_var_str
5432                    .into_iter()
5433                    .map(|p| p.to_string())
5434                    .collect::<Vec<String>>()
5435                    .join(",")
5436                    .to_string(),
5437            )]),
5438        };
5439    }
5440    if let Some(ref local_var_str) = slug__ie {
5441        local_var_req_builder = match "multi" {
5442            "multi" => local_var_req_builder.query(
5443                &local_var_str
5444                    .into_iter()
5445                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
5446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5447            ),
5448            _ => local_var_req_builder.query(&[(
5449                "slug__ie",
5450                &local_var_str
5451                    .into_iter()
5452                    .map(|p| p.to_string())
5453                    .collect::<Vec<String>>()
5454                    .join(",")
5455                    .to_string(),
5456            )]),
5457        };
5458    }
5459    if let Some(ref local_var_str) = slug__iew {
5460        local_var_req_builder = match "multi" {
5461            "multi" => local_var_req_builder.query(
5462                &local_var_str
5463                    .into_iter()
5464                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
5465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5466            ),
5467            _ => local_var_req_builder.query(&[(
5468                "slug__iew",
5469                &local_var_str
5470                    .into_iter()
5471                    .map(|p| p.to_string())
5472                    .collect::<Vec<String>>()
5473                    .join(",")
5474                    .to_string(),
5475            )]),
5476        };
5477    }
5478    if let Some(ref local_var_str) = slug__iregex {
5479        local_var_req_builder = match "multi" {
5480            "multi" => local_var_req_builder.query(
5481                &local_var_str
5482                    .into_iter()
5483                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
5484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5485            ),
5486            _ => local_var_req_builder.query(&[(
5487                "slug__iregex",
5488                &local_var_str
5489                    .into_iter()
5490                    .map(|p| p.to_string())
5491                    .collect::<Vec<String>>()
5492                    .join(",")
5493                    .to_string(),
5494            )]),
5495        };
5496    }
5497    if let Some(ref local_var_str) = slug__isw {
5498        local_var_req_builder = match "multi" {
5499            "multi" => local_var_req_builder.query(
5500                &local_var_str
5501                    .into_iter()
5502                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
5503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5504            ),
5505            _ => local_var_req_builder.query(&[(
5506                "slug__isw",
5507                &local_var_str
5508                    .into_iter()
5509                    .map(|p| p.to_string())
5510                    .collect::<Vec<String>>()
5511                    .join(",")
5512                    .to_string(),
5513            )]),
5514        };
5515    }
5516    if let Some(ref local_var_str) = slug__n {
5517        local_var_req_builder = match "multi" {
5518            "multi" => local_var_req_builder.query(
5519                &local_var_str
5520                    .into_iter()
5521                    .map(|p| ("slug__n".to_owned(), p.to_string()))
5522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5523            ),
5524            _ => local_var_req_builder.query(&[(
5525                "slug__n",
5526                &local_var_str
5527                    .into_iter()
5528                    .map(|p| p.to_string())
5529                    .collect::<Vec<String>>()
5530                    .join(",")
5531                    .to_string(),
5532            )]),
5533        };
5534    }
5535    if let Some(ref local_var_str) = slug__nic {
5536        local_var_req_builder = match "multi" {
5537            "multi" => local_var_req_builder.query(
5538                &local_var_str
5539                    .into_iter()
5540                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
5541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5542            ),
5543            _ => local_var_req_builder.query(&[(
5544                "slug__nic",
5545                &local_var_str
5546                    .into_iter()
5547                    .map(|p| p.to_string())
5548                    .collect::<Vec<String>>()
5549                    .join(",")
5550                    .to_string(),
5551            )]),
5552        };
5553    }
5554    if let Some(ref local_var_str) = slug__nie {
5555        local_var_req_builder = match "multi" {
5556            "multi" => local_var_req_builder.query(
5557                &local_var_str
5558                    .into_iter()
5559                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
5560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5561            ),
5562            _ => local_var_req_builder.query(&[(
5563                "slug__nie",
5564                &local_var_str
5565                    .into_iter()
5566                    .map(|p| p.to_string())
5567                    .collect::<Vec<String>>()
5568                    .join(",")
5569                    .to_string(),
5570            )]),
5571        };
5572    }
5573    if let Some(ref local_var_str) = slug__niew {
5574        local_var_req_builder = match "multi" {
5575            "multi" => local_var_req_builder.query(
5576                &local_var_str
5577                    .into_iter()
5578                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
5579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5580            ),
5581            _ => local_var_req_builder.query(&[(
5582                "slug__niew",
5583                &local_var_str
5584                    .into_iter()
5585                    .map(|p| p.to_string())
5586                    .collect::<Vec<String>>()
5587                    .join(",")
5588                    .to_string(),
5589            )]),
5590        };
5591    }
5592    if let Some(ref local_var_str) = slug__nisw {
5593        local_var_req_builder = match "multi" {
5594            "multi" => local_var_req_builder.query(
5595                &local_var_str
5596                    .into_iter()
5597                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
5598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5599            ),
5600            _ => local_var_req_builder.query(&[(
5601                "slug__nisw",
5602                &local_var_str
5603                    .into_iter()
5604                    .map(|p| p.to_string())
5605                    .collect::<Vec<String>>()
5606                    .join(",")
5607                    .to_string(),
5608            )]),
5609        };
5610    }
5611    if let Some(ref local_var_str) = slug__regex {
5612        local_var_req_builder = match "multi" {
5613            "multi" => local_var_req_builder.query(
5614                &local_var_str
5615                    .into_iter()
5616                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
5617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5618            ),
5619            _ => local_var_req_builder.query(&[(
5620                "slug__regex",
5621                &local_var_str
5622                    .into_iter()
5623                    .map(|p| p.to_string())
5624                    .collect::<Vec<String>>()
5625                    .join(",")
5626                    .to_string(),
5627            )]),
5628        };
5629    }
5630    if let Some(ref local_var_str) = tag {
5631        local_var_req_builder = match "multi" {
5632            "multi" => local_var_req_builder.query(
5633                &local_var_str
5634                    .into_iter()
5635                    .map(|p| ("tag".to_owned(), p.to_string()))
5636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5637            ),
5638            _ => local_var_req_builder.query(&[(
5639                "tag",
5640                &local_var_str
5641                    .into_iter()
5642                    .map(|p| p.to_string())
5643                    .collect::<Vec<String>>()
5644                    .join(",")
5645                    .to_string(),
5646            )]),
5647        };
5648    }
5649    if let Some(ref local_var_str) = tag__n {
5650        local_var_req_builder = match "multi" {
5651            "multi" => local_var_req_builder.query(
5652                &local_var_str
5653                    .into_iter()
5654                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5656            ),
5657            _ => local_var_req_builder.query(&[(
5658                "tag__n",
5659                &local_var_str
5660                    .into_iter()
5661                    .map(|p| p.to_string())
5662                    .collect::<Vec<String>>()
5663                    .join(",")
5664                    .to_string(),
5665            )]),
5666        };
5667    }
5668    if let Some(ref local_var_str) = tag_id {
5669        local_var_req_builder = match "multi" {
5670            "multi" => local_var_req_builder.query(
5671                &local_var_str
5672                    .into_iter()
5673                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5675            ),
5676            _ => local_var_req_builder.query(&[(
5677                "tag_id",
5678                &local_var_str
5679                    .into_iter()
5680                    .map(|p| p.to_string())
5681                    .collect::<Vec<String>>()
5682                    .join(",")
5683                    .to_string(),
5684            )]),
5685        };
5686    }
5687    if let Some(ref local_var_str) = tag_id__n {
5688        local_var_req_builder = match "multi" {
5689            "multi" => local_var_req_builder.query(
5690                &local_var_str
5691                    .into_iter()
5692                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5694            ),
5695            _ => local_var_req_builder.query(&[(
5696                "tag_id__n",
5697                &local_var_str
5698                    .into_iter()
5699                    .map(|p| p.to_string())
5700                    .collect::<Vec<String>>()
5701                    .join(",")
5702                    .to_string(),
5703            )]),
5704        };
5705    }
5706    if let Some(ref local_var_str) = updated_by_request {
5707        local_var_req_builder =
5708            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5709    }
5710    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5711        local_var_req_builder =
5712            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5713    }
5714    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5715        let local_var_key = local_var_apikey.key.clone();
5716        let local_var_value = match local_var_apikey.prefix {
5717            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5718            None => local_var_key,
5719        };
5720        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5721    };
5722
5723    let local_var_req = local_var_req_builder.build()?;
5724    let local_var_resp = local_var_client.execute(local_var_req).await?;
5725
5726    let local_var_status = local_var_resp.status();
5727    let local_var_content = local_var_resp.text().await?;
5728
5729    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5730        serde_json::from_str(&local_var_content).map_err(Error::from)
5731    } else {
5732        let local_var_entity: Option<TenancyContactRolesListError> =
5733            serde_json::from_str(&local_var_content).ok();
5734        let local_var_error = ResponseContent {
5735            status: local_var_status,
5736            content: local_var_content,
5737            entity: local_var_entity,
5738        };
5739        Err(Error::ResponseError(local_var_error))
5740    }
5741}
5742
5743/// Patch a contact role object.
5744pub async fn tenancy_contact_roles_partial_update(
5745    configuration: &configuration::Configuration,
5746    id: i32,
5747    patched_contact_role_request: Option<crate::models::PatchedContactRoleRequest>,
5748) -> Result<crate::models::ContactRole, Error<TenancyContactRolesPartialUpdateError>> {
5749    let local_var_configuration = configuration;
5750
5751    let local_var_client = &local_var_configuration.client;
5752
5753    let local_var_uri_str = format!(
5754        "{}/api/tenancy/contact-roles/{id}/",
5755        local_var_configuration.base_path,
5756        id = id
5757    );
5758    let mut local_var_req_builder =
5759        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5760
5761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5762        local_var_req_builder =
5763            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5764    }
5765    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5766        let local_var_key = local_var_apikey.key.clone();
5767        let local_var_value = match local_var_apikey.prefix {
5768            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5769            None => local_var_key,
5770        };
5771        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5772    };
5773    local_var_req_builder = local_var_req_builder.json(&patched_contact_role_request);
5774
5775    let local_var_req = local_var_req_builder.build()?;
5776    let local_var_resp = local_var_client.execute(local_var_req).await?;
5777
5778    let local_var_status = local_var_resp.status();
5779    let local_var_content = local_var_resp.text().await?;
5780
5781    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5782        serde_json::from_str(&local_var_content).map_err(Error::from)
5783    } else {
5784        let local_var_entity: Option<TenancyContactRolesPartialUpdateError> =
5785            serde_json::from_str(&local_var_content).ok();
5786        let local_var_error = ResponseContent {
5787            status: local_var_status,
5788            content: local_var_content,
5789            entity: local_var_entity,
5790        };
5791        Err(Error::ResponseError(local_var_error))
5792    }
5793}
5794
5795/// Get a contact role object.
5796pub async fn tenancy_contact_roles_retrieve(
5797    configuration: &configuration::Configuration,
5798    id: i32,
5799) -> Result<crate::models::ContactRole, Error<TenancyContactRolesRetrieveError>> {
5800    let local_var_configuration = configuration;
5801
5802    let local_var_client = &local_var_configuration.client;
5803
5804    let local_var_uri_str = format!(
5805        "{}/api/tenancy/contact-roles/{id}/",
5806        local_var_configuration.base_path,
5807        id = id
5808    );
5809    let mut local_var_req_builder =
5810        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5811
5812    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5813        local_var_req_builder =
5814            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5815    }
5816    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5817        let local_var_key = local_var_apikey.key.clone();
5818        let local_var_value = match local_var_apikey.prefix {
5819            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5820            None => local_var_key,
5821        };
5822        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5823    };
5824
5825    let local_var_req = local_var_req_builder.build()?;
5826    let local_var_resp = local_var_client.execute(local_var_req).await?;
5827
5828    let local_var_status = local_var_resp.status();
5829    let local_var_content = local_var_resp.text().await?;
5830
5831    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5832        serde_json::from_str(&local_var_content).map_err(Error::from)
5833    } else {
5834        let local_var_entity: Option<TenancyContactRolesRetrieveError> =
5835            serde_json::from_str(&local_var_content).ok();
5836        let local_var_error = ResponseContent {
5837            status: local_var_status,
5838            content: local_var_content,
5839            entity: local_var_entity,
5840        };
5841        Err(Error::ResponseError(local_var_error))
5842    }
5843}
5844
5845/// Put a contact role object.
5846pub async fn tenancy_contact_roles_update(
5847    configuration: &configuration::Configuration,
5848    id: i32,
5849    contact_role_request: crate::models::ContactRoleRequest,
5850) -> Result<crate::models::ContactRole, Error<TenancyContactRolesUpdateError>> {
5851    let local_var_configuration = configuration;
5852
5853    let local_var_client = &local_var_configuration.client;
5854
5855    let local_var_uri_str = format!(
5856        "{}/api/tenancy/contact-roles/{id}/",
5857        local_var_configuration.base_path,
5858        id = id
5859    );
5860    let mut local_var_req_builder =
5861        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5862
5863    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5864        local_var_req_builder =
5865            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5866    }
5867    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5868        let local_var_key = local_var_apikey.key.clone();
5869        let local_var_value = match local_var_apikey.prefix {
5870            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5871            None => local_var_key,
5872        };
5873        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5874    };
5875    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
5876
5877    let local_var_req = local_var_req_builder.build()?;
5878    let local_var_resp = local_var_client.execute(local_var_req).await?;
5879
5880    let local_var_status = local_var_resp.status();
5881    let local_var_content = local_var_resp.text().await?;
5882
5883    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5884        serde_json::from_str(&local_var_content).map_err(Error::from)
5885    } else {
5886        let local_var_entity: Option<TenancyContactRolesUpdateError> =
5887            serde_json::from_str(&local_var_content).ok();
5888        let local_var_error = ResponseContent {
5889            status: local_var_status,
5890            content: local_var_content,
5891            entity: local_var_entity,
5892        };
5893        Err(Error::ResponseError(local_var_error))
5894    }
5895}
5896
5897/// Delete a list of contact objects.
5898pub async fn tenancy_contacts_bulk_destroy(
5899    configuration: &configuration::Configuration,
5900    contact_request: Vec<crate::models::ContactRequest>,
5901) -> Result<(), Error<TenancyContactsBulkDestroyError>> {
5902    let local_var_configuration = configuration;
5903
5904    let local_var_client = &local_var_configuration.client;
5905
5906    let local_var_uri_str = format!(
5907        "{}/api/tenancy/contacts/",
5908        local_var_configuration.base_path
5909    );
5910    let mut local_var_req_builder =
5911        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5912
5913    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5914        local_var_req_builder =
5915            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5916    }
5917    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5918        let local_var_key = local_var_apikey.key.clone();
5919        let local_var_value = match local_var_apikey.prefix {
5920            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5921            None => local_var_key,
5922        };
5923        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5924    };
5925    local_var_req_builder = local_var_req_builder.json(&contact_request);
5926
5927    let local_var_req = local_var_req_builder.build()?;
5928    let local_var_resp = local_var_client.execute(local_var_req).await?;
5929
5930    let local_var_status = local_var_resp.status();
5931    let local_var_content = local_var_resp.text().await?;
5932
5933    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5934        Ok(())
5935    } else {
5936        let local_var_entity: Option<TenancyContactsBulkDestroyError> =
5937            serde_json::from_str(&local_var_content).ok();
5938        let local_var_error = ResponseContent {
5939            status: local_var_status,
5940            content: local_var_content,
5941            entity: local_var_entity,
5942        };
5943        Err(Error::ResponseError(local_var_error))
5944    }
5945}
5946
5947/// Patch a list of contact objects.
5948pub async fn tenancy_contacts_bulk_partial_update(
5949    configuration: &configuration::Configuration,
5950    contact_request: Vec<crate::models::ContactRequest>,
5951) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkPartialUpdateError>> {
5952    let local_var_configuration = configuration;
5953
5954    let local_var_client = &local_var_configuration.client;
5955
5956    let local_var_uri_str = format!(
5957        "{}/api/tenancy/contacts/",
5958        local_var_configuration.base_path
5959    );
5960    let mut local_var_req_builder =
5961        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5962
5963    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5964        local_var_req_builder =
5965            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5966    }
5967    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5968        let local_var_key = local_var_apikey.key.clone();
5969        let local_var_value = match local_var_apikey.prefix {
5970            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5971            None => local_var_key,
5972        };
5973        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5974    };
5975    local_var_req_builder = local_var_req_builder.json(&contact_request);
5976
5977    let local_var_req = local_var_req_builder.build()?;
5978    let local_var_resp = local_var_client.execute(local_var_req).await?;
5979
5980    let local_var_status = local_var_resp.status();
5981    let local_var_content = local_var_resp.text().await?;
5982
5983    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5984        serde_json::from_str(&local_var_content).map_err(Error::from)
5985    } else {
5986        let local_var_entity: Option<TenancyContactsBulkPartialUpdateError> =
5987            serde_json::from_str(&local_var_content).ok();
5988        let local_var_error = ResponseContent {
5989            status: local_var_status,
5990            content: local_var_content,
5991            entity: local_var_entity,
5992        };
5993        Err(Error::ResponseError(local_var_error))
5994    }
5995}
5996
5997/// Put a list of contact objects.
5998pub async fn tenancy_contacts_bulk_update(
5999    configuration: &configuration::Configuration,
6000    contact_request: Vec<crate::models::ContactRequest>,
6001) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkUpdateError>> {
6002    let local_var_configuration = configuration;
6003
6004    let local_var_client = &local_var_configuration.client;
6005
6006    let local_var_uri_str = format!(
6007        "{}/api/tenancy/contacts/",
6008        local_var_configuration.base_path
6009    );
6010    let mut local_var_req_builder =
6011        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6012
6013    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6014        local_var_req_builder =
6015            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6016    }
6017    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6018        let local_var_key = local_var_apikey.key.clone();
6019        let local_var_value = match local_var_apikey.prefix {
6020            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6021            None => local_var_key,
6022        };
6023        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6024    };
6025    local_var_req_builder = local_var_req_builder.json(&contact_request);
6026
6027    let local_var_req = local_var_req_builder.build()?;
6028    let local_var_resp = local_var_client.execute(local_var_req).await?;
6029
6030    let local_var_status = local_var_resp.status();
6031    let local_var_content = local_var_resp.text().await?;
6032
6033    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6034        serde_json::from_str(&local_var_content).map_err(Error::from)
6035    } else {
6036        let local_var_entity: Option<TenancyContactsBulkUpdateError> =
6037            serde_json::from_str(&local_var_content).ok();
6038        let local_var_error = ResponseContent {
6039            status: local_var_status,
6040            content: local_var_content,
6041            entity: local_var_entity,
6042        };
6043        Err(Error::ResponseError(local_var_error))
6044    }
6045}
6046
6047/// Post a list of contact objects.
6048pub async fn tenancy_contacts_create(
6049    configuration: &configuration::Configuration,
6050    tenancy_contacts_create_request: crate::models::TenancyContactsCreateRequest,
6051) -> Result<crate::models::Contact, Error<TenancyContactsCreateError>> {
6052    let local_var_configuration = configuration;
6053
6054    let local_var_client = &local_var_configuration.client;
6055
6056    let local_var_uri_str = format!(
6057        "{}/api/tenancy/contacts/",
6058        local_var_configuration.base_path
6059    );
6060    let mut local_var_req_builder =
6061        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6062
6063    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6064        local_var_req_builder =
6065            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6066    }
6067    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6068        let local_var_key = local_var_apikey.key.clone();
6069        let local_var_value = match local_var_apikey.prefix {
6070            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6071            None => local_var_key,
6072        };
6073        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6074    };
6075    local_var_req_builder = local_var_req_builder.json(&tenancy_contacts_create_request);
6076
6077    let local_var_req = local_var_req_builder.build()?;
6078    let local_var_resp = local_var_client.execute(local_var_req).await?;
6079
6080    let local_var_status = local_var_resp.status();
6081    let local_var_content = local_var_resp.text().await?;
6082
6083    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6084        serde_json::from_str(&local_var_content).map_err(Error::from)
6085    } else {
6086        let local_var_entity: Option<TenancyContactsCreateError> =
6087            serde_json::from_str(&local_var_content).ok();
6088        let local_var_error = ResponseContent {
6089            status: local_var_status,
6090            content: local_var_content,
6091            entity: local_var_entity,
6092        };
6093        Err(Error::ResponseError(local_var_error))
6094    }
6095}
6096
6097/// Delete a contact object.
6098pub async fn tenancy_contacts_destroy(
6099    configuration: &configuration::Configuration,
6100    id: i32,
6101) -> Result<(), Error<TenancyContactsDestroyError>> {
6102    let local_var_configuration = configuration;
6103
6104    let local_var_client = &local_var_configuration.client;
6105
6106    let local_var_uri_str = format!(
6107        "{}/api/tenancy/contacts/{id}/",
6108        local_var_configuration.base_path,
6109        id = id
6110    );
6111    let mut local_var_req_builder =
6112        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6113
6114    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6115        local_var_req_builder =
6116            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6117    }
6118    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6119        let local_var_key = local_var_apikey.key.clone();
6120        let local_var_value = match local_var_apikey.prefix {
6121            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6122            None => local_var_key,
6123        };
6124        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6125    };
6126
6127    let local_var_req = local_var_req_builder.build()?;
6128    let local_var_resp = local_var_client.execute(local_var_req).await?;
6129
6130    let local_var_status = local_var_resp.status();
6131    let local_var_content = local_var_resp.text().await?;
6132
6133    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6134        Ok(())
6135    } else {
6136        let local_var_entity: Option<TenancyContactsDestroyError> =
6137            serde_json::from_str(&local_var_content).ok();
6138        let local_var_error = ResponseContent {
6139            status: local_var_status,
6140            content: local_var_content,
6141            entity: local_var_entity,
6142        };
6143        Err(Error::ResponseError(local_var_error))
6144    }
6145}
6146
6147/// Get a list of contact objects.
6148pub async fn tenancy_contacts_list(
6149    configuration: &configuration::Configuration,
6150    address: Option<Vec<String>>,
6151    address__empty: Option<bool>,
6152    address__ic: Option<Vec<String>>,
6153    address__ie: Option<Vec<String>>,
6154    address__iew: Option<Vec<String>>,
6155    address__iregex: Option<Vec<String>>,
6156    address__isw: Option<Vec<String>>,
6157    address__n: Option<Vec<String>>,
6158    address__nic: Option<Vec<String>>,
6159    address__nie: Option<Vec<String>>,
6160    address__niew: Option<Vec<String>>,
6161    address__nisw: Option<Vec<String>>,
6162    address__regex: Option<Vec<String>>,
6163    created: Option<Vec<String>>,
6164    created__empty: Option<Vec<String>>,
6165    created__gt: Option<Vec<String>>,
6166    created__gte: Option<Vec<String>>,
6167    created__lt: Option<Vec<String>>,
6168    created__lte: Option<Vec<String>>,
6169    created__n: Option<Vec<String>>,
6170    created_by_request: Option<&str>,
6171    description: Option<Vec<String>>,
6172    description__empty: Option<bool>,
6173    description__ic: Option<Vec<String>>,
6174    description__ie: Option<Vec<String>>,
6175    description__iew: Option<Vec<String>>,
6176    description__iregex: Option<Vec<String>>,
6177    description__isw: Option<Vec<String>>,
6178    description__n: Option<Vec<String>>,
6179    description__nic: Option<Vec<String>>,
6180    description__nie: Option<Vec<String>>,
6181    description__niew: Option<Vec<String>>,
6182    description__nisw: Option<Vec<String>>,
6183    description__regex: Option<Vec<String>>,
6184    email: Option<Vec<String>>,
6185    email__empty: Option<bool>,
6186    email__ic: Option<Vec<String>>,
6187    email__ie: Option<Vec<String>>,
6188    email__iew: Option<Vec<String>>,
6189    email__iregex: Option<Vec<String>>,
6190    email__isw: Option<Vec<String>>,
6191    email__n: Option<Vec<String>>,
6192    email__nic: Option<Vec<String>>,
6193    email__nie: Option<Vec<String>>,
6194    email__niew: Option<Vec<String>>,
6195    email__nisw: Option<Vec<String>>,
6196    email__regex: Option<Vec<String>>,
6197    group: Option<Vec<String>>,
6198    group__n: Option<Vec<String>>,
6199    group_id: Option<Vec<String>>,
6200    group_id__n: Option<Vec<String>>,
6201    id: Option<Vec<i32>>,
6202    id__empty: Option<bool>,
6203    id__gt: Option<Vec<i32>>,
6204    id__gte: Option<Vec<i32>>,
6205    id__lt: Option<Vec<i32>>,
6206    id__lte: Option<Vec<i32>>,
6207    id__n: Option<Vec<i32>>,
6208    last_updated: Option<Vec<String>>,
6209    last_updated__empty: Option<Vec<String>>,
6210    last_updated__gt: Option<Vec<String>>,
6211    last_updated__gte: Option<Vec<String>>,
6212    last_updated__lt: Option<Vec<String>>,
6213    last_updated__lte: Option<Vec<String>>,
6214    last_updated__n: Option<Vec<String>>,
6215    limit: Option<i32>,
6216    link: Option<Vec<String>>,
6217    link__empty: Option<bool>,
6218    link__ic: Option<Vec<String>>,
6219    link__ie: Option<Vec<String>>,
6220    link__iew: Option<Vec<String>>,
6221    link__iregex: Option<Vec<String>>,
6222    link__isw: Option<Vec<String>>,
6223    link__n: Option<Vec<String>>,
6224    link__nic: Option<Vec<String>>,
6225    link__nie: Option<Vec<String>>,
6226    link__niew: Option<Vec<String>>,
6227    link__nisw: Option<Vec<String>>,
6228    link__regex: Option<Vec<String>>,
6229    modified_by_request: Option<&str>,
6230    name: Option<Vec<String>>,
6231    name__empty: Option<bool>,
6232    name__ic: Option<Vec<String>>,
6233    name__ie: Option<Vec<String>>,
6234    name__iew: Option<Vec<String>>,
6235    name__iregex: Option<Vec<String>>,
6236    name__isw: Option<Vec<String>>,
6237    name__n: Option<Vec<String>>,
6238    name__nic: Option<Vec<String>>,
6239    name__nie: Option<Vec<String>>,
6240    name__niew: Option<Vec<String>>,
6241    name__nisw: Option<Vec<String>>,
6242    name__regex: Option<Vec<String>>,
6243    offset: Option<i32>,
6244    ordering: Option<&str>,
6245    owner: Option<Vec<String>>,
6246    owner__n: Option<Vec<String>>,
6247    owner_group: Option<Vec<String>>,
6248    owner_group__n: Option<Vec<String>>,
6249    owner_group_id: Option<Vec<i32>>,
6250    owner_group_id__n: Option<Vec<i32>>,
6251    owner_id: Option<Vec<i32>>,
6252    owner_id__n: Option<Vec<i32>>,
6253    phone: Option<Vec<String>>,
6254    phone__empty: Option<bool>,
6255    phone__ic: Option<Vec<String>>,
6256    phone__ie: Option<Vec<String>>,
6257    phone__iew: Option<Vec<String>>,
6258    phone__iregex: Option<Vec<String>>,
6259    phone__isw: Option<Vec<String>>,
6260    phone__n: Option<Vec<String>>,
6261    phone__nic: Option<Vec<String>>,
6262    phone__nie: Option<Vec<String>>,
6263    phone__niew: Option<Vec<String>>,
6264    phone__nisw: Option<Vec<String>>,
6265    phone__regex: Option<Vec<String>>,
6266    q: Option<&str>,
6267    tag: Option<Vec<String>>,
6268    tag__n: Option<Vec<String>>,
6269    tag_id: Option<Vec<i32>>,
6270    tag_id__n: Option<Vec<i32>>,
6271    title: Option<Vec<String>>,
6272    title__empty: Option<bool>,
6273    title__ic: Option<Vec<String>>,
6274    title__ie: Option<Vec<String>>,
6275    title__iew: Option<Vec<String>>,
6276    title__iregex: Option<Vec<String>>,
6277    title__isw: Option<Vec<String>>,
6278    title__n: Option<Vec<String>>,
6279    title__nic: Option<Vec<String>>,
6280    title__nie: Option<Vec<String>>,
6281    title__niew: Option<Vec<String>>,
6282    title__nisw: Option<Vec<String>>,
6283    title__regex: Option<Vec<String>>,
6284    updated_by_request: Option<&str>,
6285) -> Result<crate::models::PaginatedContactList, Error<TenancyContactsListError>> {
6286    let local_var_configuration = configuration;
6287
6288    let local_var_client = &local_var_configuration.client;
6289
6290    let local_var_uri_str = format!(
6291        "{}/api/tenancy/contacts/",
6292        local_var_configuration.base_path
6293    );
6294    let mut local_var_req_builder =
6295        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6296
6297    if let Some(ref local_var_str) = address {
6298        local_var_req_builder = match "multi" {
6299            "multi" => local_var_req_builder.query(
6300                &local_var_str
6301                    .into_iter()
6302                    .map(|p| ("address".to_owned(), p.to_string()))
6303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6304            ),
6305            _ => local_var_req_builder.query(&[(
6306                "address",
6307                &local_var_str
6308                    .into_iter()
6309                    .map(|p| p.to_string())
6310                    .collect::<Vec<String>>()
6311                    .join(",")
6312                    .to_string(),
6313            )]),
6314        };
6315    }
6316    if let Some(ref local_var_str) = address__empty {
6317        local_var_req_builder =
6318            local_var_req_builder.query(&[("address__empty", &local_var_str.to_string())]);
6319    }
6320    if let Some(ref local_var_str) = address__ic {
6321        local_var_req_builder = match "multi" {
6322            "multi" => local_var_req_builder.query(
6323                &local_var_str
6324                    .into_iter()
6325                    .map(|p| ("address__ic".to_owned(), p.to_string()))
6326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6327            ),
6328            _ => local_var_req_builder.query(&[(
6329                "address__ic",
6330                &local_var_str
6331                    .into_iter()
6332                    .map(|p| p.to_string())
6333                    .collect::<Vec<String>>()
6334                    .join(",")
6335                    .to_string(),
6336            )]),
6337        };
6338    }
6339    if let Some(ref local_var_str) = address__ie {
6340        local_var_req_builder = match "multi" {
6341            "multi" => local_var_req_builder.query(
6342                &local_var_str
6343                    .into_iter()
6344                    .map(|p| ("address__ie".to_owned(), p.to_string()))
6345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6346            ),
6347            _ => local_var_req_builder.query(&[(
6348                "address__ie",
6349                &local_var_str
6350                    .into_iter()
6351                    .map(|p| p.to_string())
6352                    .collect::<Vec<String>>()
6353                    .join(",")
6354                    .to_string(),
6355            )]),
6356        };
6357    }
6358    if let Some(ref local_var_str) = address__iew {
6359        local_var_req_builder = match "multi" {
6360            "multi" => local_var_req_builder.query(
6361                &local_var_str
6362                    .into_iter()
6363                    .map(|p| ("address__iew".to_owned(), p.to_string()))
6364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6365            ),
6366            _ => local_var_req_builder.query(&[(
6367                "address__iew",
6368                &local_var_str
6369                    .into_iter()
6370                    .map(|p| p.to_string())
6371                    .collect::<Vec<String>>()
6372                    .join(",")
6373                    .to_string(),
6374            )]),
6375        };
6376    }
6377    if let Some(ref local_var_str) = address__iregex {
6378        local_var_req_builder = match "multi" {
6379            "multi" => local_var_req_builder.query(
6380                &local_var_str
6381                    .into_iter()
6382                    .map(|p| ("address__iregex".to_owned(), p.to_string()))
6383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6384            ),
6385            _ => local_var_req_builder.query(&[(
6386                "address__iregex",
6387                &local_var_str
6388                    .into_iter()
6389                    .map(|p| p.to_string())
6390                    .collect::<Vec<String>>()
6391                    .join(",")
6392                    .to_string(),
6393            )]),
6394        };
6395    }
6396    if let Some(ref local_var_str) = address__isw {
6397        local_var_req_builder = match "multi" {
6398            "multi" => local_var_req_builder.query(
6399                &local_var_str
6400                    .into_iter()
6401                    .map(|p| ("address__isw".to_owned(), p.to_string()))
6402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6403            ),
6404            _ => local_var_req_builder.query(&[(
6405                "address__isw",
6406                &local_var_str
6407                    .into_iter()
6408                    .map(|p| p.to_string())
6409                    .collect::<Vec<String>>()
6410                    .join(",")
6411                    .to_string(),
6412            )]),
6413        };
6414    }
6415    if let Some(ref local_var_str) = address__n {
6416        local_var_req_builder = match "multi" {
6417            "multi" => local_var_req_builder.query(
6418                &local_var_str
6419                    .into_iter()
6420                    .map(|p| ("address__n".to_owned(), p.to_string()))
6421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6422            ),
6423            _ => local_var_req_builder.query(&[(
6424                "address__n",
6425                &local_var_str
6426                    .into_iter()
6427                    .map(|p| p.to_string())
6428                    .collect::<Vec<String>>()
6429                    .join(",")
6430                    .to_string(),
6431            )]),
6432        };
6433    }
6434    if let Some(ref local_var_str) = address__nic {
6435        local_var_req_builder = match "multi" {
6436            "multi" => local_var_req_builder.query(
6437                &local_var_str
6438                    .into_iter()
6439                    .map(|p| ("address__nic".to_owned(), p.to_string()))
6440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6441            ),
6442            _ => local_var_req_builder.query(&[(
6443                "address__nic",
6444                &local_var_str
6445                    .into_iter()
6446                    .map(|p| p.to_string())
6447                    .collect::<Vec<String>>()
6448                    .join(",")
6449                    .to_string(),
6450            )]),
6451        };
6452    }
6453    if let Some(ref local_var_str) = address__nie {
6454        local_var_req_builder = match "multi" {
6455            "multi" => local_var_req_builder.query(
6456                &local_var_str
6457                    .into_iter()
6458                    .map(|p| ("address__nie".to_owned(), p.to_string()))
6459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6460            ),
6461            _ => local_var_req_builder.query(&[(
6462                "address__nie",
6463                &local_var_str
6464                    .into_iter()
6465                    .map(|p| p.to_string())
6466                    .collect::<Vec<String>>()
6467                    .join(",")
6468                    .to_string(),
6469            )]),
6470        };
6471    }
6472    if let Some(ref local_var_str) = address__niew {
6473        local_var_req_builder = match "multi" {
6474            "multi" => local_var_req_builder.query(
6475                &local_var_str
6476                    .into_iter()
6477                    .map(|p| ("address__niew".to_owned(), p.to_string()))
6478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6479            ),
6480            _ => local_var_req_builder.query(&[(
6481                "address__niew",
6482                &local_var_str
6483                    .into_iter()
6484                    .map(|p| p.to_string())
6485                    .collect::<Vec<String>>()
6486                    .join(",")
6487                    .to_string(),
6488            )]),
6489        };
6490    }
6491    if let Some(ref local_var_str) = address__nisw {
6492        local_var_req_builder = match "multi" {
6493            "multi" => local_var_req_builder.query(
6494                &local_var_str
6495                    .into_iter()
6496                    .map(|p| ("address__nisw".to_owned(), p.to_string()))
6497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6498            ),
6499            _ => local_var_req_builder.query(&[(
6500                "address__nisw",
6501                &local_var_str
6502                    .into_iter()
6503                    .map(|p| p.to_string())
6504                    .collect::<Vec<String>>()
6505                    .join(",")
6506                    .to_string(),
6507            )]),
6508        };
6509    }
6510    if let Some(ref local_var_str) = address__regex {
6511        local_var_req_builder = match "multi" {
6512            "multi" => local_var_req_builder.query(
6513                &local_var_str
6514                    .into_iter()
6515                    .map(|p| ("address__regex".to_owned(), p.to_string()))
6516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6517            ),
6518            _ => local_var_req_builder.query(&[(
6519                "address__regex",
6520                &local_var_str
6521                    .into_iter()
6522                    .map(|p| p.to_string())
6523                    .collect::<Vec<String>>()
6524                    .join(",")
6525                    .to_string(),
6526            )]),
6527        };
6528    }
6529    if let Some(ref local_var_str) = created {
6530        local_var_req_builder = match "multi" {
6531            "multi" => local_var_req_builder.query(
6532                &local_var_str
6533                    .into_iter()
6534                    .map(|p| ("created".to_owned(), p.to_string()))
6535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6536            ),
6537            _ => local_var_req_builder.query(&[(
6538                "created",
6539                &local_var_str
6540                    .into_iter()
6541                    .map(|p| p.to_string())
6542                    .collect::<Vec<String>>()
6543                    .join(",")
6544                    .to_string(),
6545            )]),
6546        };
6547    }
6548    if let Some(ref local_var_str) = created__empty {
6549        local_var_req_builder = match "multi" {
6550            "multi" => local_var_req_builder.query(
6551                &local_var_str
6552                    .into_iter()
6553                    .map(|p| ("created__empty".to_owned(), p.to_string()))
6554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6555            ),
6556            _ => local_var_req_builder.query(&[(
6557                "created__empty",
6558                &local_var_str
6559                    .into_iter()
6560                    .map(|p| p.to_string())
6561                    .collect::<Vec<String>>()
6562                    .join(",")
6563                    .to_string(),
6564            )]),
6565        };
6566    }
6567    if let Some(ref local_var_str) = created__gt {
6568        local_var_req_builder = match "multi" {
6569            "multi" => local_var_req_builder.query(
6570                &local_var_str
6571                    .into_iter()
6572                    .map(|p| ("created__gt".to_owned(), p.to_string()))
6573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6574            ),
6575            _ => local_var_req_builder.query(&[(
6576                "created__gt",
6577                &local_var_str
6578                    .into_iter()
6579                    .map(|p| p.to_string())
6580                    .collect::<Vec<String>>()
6581                    .join(",")
6582                    .to_string(),
6583            )]),
6584        };
6585    }
6586    if let Some(ref local_var_str) = created__gte {
6587        local_var_req_builder = match "multi" {
6588            "multi" => local_var_req_builder.query(
6589                &local_var_str
6590                    .into_iter()
6591                    .map(|p| ("created__gte".to_owned(), p.to_string()))
6592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6593            ),
6594            _ => local_var_req_builder.query(&[(
6595                "created__gte",
6596                &local_var_str
6597                    .into_iter()
6598                    .map(|p| p.to_string())
6599                    .collect::<Vec<String>>()
6600                    .join(",")
6601                    .to_string(),
6602            )]),
6603        };
6604    }
6605    if let Some(ref local_var_str) = created__lt {
6606        local_var_req_builder = match "multi" {
6607            "multi" => local_var_req_builder.query(
6608                &local_var_str
6609                    .into_iter()
6610                    .map(|p| ("created__lt".to_owned(), p.to_string()))
6611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6612            ),
6613            _ => local_var_req_builder.query(&[(
6614                "created__lt",
6615                &local_var_str
6616                    .into_iter()
6617                    .map(|p| p.to_string())
6618                    .collect::<Vec<String>>()
6619                    .join(",")
6620                    .to_string(),
6621            )]),
6622        };
6623    }
6624    if let Some(ref local_var_str) = created__lte {
6625        local_var_req_builder = match "multi" {
6626            "multi" => local_var_req_builder.query(
6627                &local_var_str
6628                    .into_iter()
6629                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6631            ),
6632            _ => local_var_req_builder.query(&[(
6633                "created__lte",
6634                &local_var_str
6635                    .into_iter()
6636                    .map(|p| p.to_string())
6637                    .collect::<Vec<String>>()
6638                    .join(",")
6639                    .to_string(),
6640            )]),
6641        };
6642    }
6643    if let Some(ref local_var_str) = created__n {
6644        local_var_req_builder = match "multi" {
6645            "multi" => local_var_req_builder.query(
6646                &local_var_str
6647                    .into_iter()
6648                    .map(|p| ("created__n".to_owned(), p.to_string()))
6649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6650            ),
6651            _ => local_var_req_builder.query(&[(
6652                "created__n",
6653                &local_var_str
6654                    .into_iter()
6655                    .map(|p| p.to_string())
6656                    .collect::<Vec<String>>()
6657                    .join(",")
6658                    .to_string(),
6659            )]),
6660        };
6661    }
6662    if let Some(ref local_var_str) = created_by_request {
6663        local_var_req_builder =
6664            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
6665    }
6666    if let Some(ref local_var_str) = description {
6667        local_var_req_builder = match "multi" {
6668            "multi" => local_var_req_builder.query(
6669                &local_var_str
6670                    .into_iter()
6671                    .map(|p| ("description".to_owned(), p.to_string()))
6672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6673            ),
6674            _ => local_var_req_builder.query(&[(
6675                "description",
6676                &local_var_str
6677                    .into_iter()
6678                    .map(|p| p.to_string())
6679                    .collect::<Vec<String>>()
6680                    .join(",")
6681                    .to_string(),
6682            )]),
6683        };
6684    }
6685    if let Some(ref local_var_str) = description__empty {
6686        local_var_req_builder =
6687            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6688    }
6689    if let Some(ref local_var_str) = description__ic {
6690        local_var_req_builder = match "multi" {
6691            "multi" => local_var_req_builder.query(
6692                &local_var_str
6693                    .into_iter()
6694                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6696            ),
6697            _ => local_var_req_builder.query(&[(
6698                "description__ic",
6699                &local_var_str
6700                    .into_iter()
6701                    .map(|p| p.to_string())
6702                    .collect::<Vec<String>>()
6703                    .join(",")
6704                    .to_string(),
6705            )]),
6706        };
6707    }
6708    if let Some(ref local_var_str) = description__ie {
6709        local_var_req_builder = match "multi" {
6710            "multi" => local_var_req_builder.query(
6711                &local_var_str
6712                    .into_iter()
6713                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6715            ),
6716            _ => local_var_req_builder.query(&[(
6717                "description__ie",
6718                &local_var_str
6719                    .into_iter()
6720                    .map(|p| p.to_string())
6721                    .collect::<Vec<String>>()
6722                    .join(",")
6723                    .to_string(),
6724            )]),
6725        };
6726    }
6727    if let Some(ref local_var_str) = description__iew {
6728        local_var_req_builder = match "multi" {
6729            "multi" => local_var_req_builder.query(
6730                &local_var_str
6731                    .into_iter()
6732                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6734            ),
6735            _ => local_var_req_builder.query(&[(
6736                "description__iew",
6737                &local_var_str
6738                    .into_iter()
6739                    .map(|p| p.to_string())
6740                    .collect::<Vec<String>>()
6741                    .join(",")
6742                    .to_string(),
6743            )]),
6744        };
6745    }
6746    if let Some(ref local_var_str) = description__iregex {
6747        local_var_req_builder = match "multi" {
6748            "multi" => local_var_req_builder.query(
6749                &local_var_str
6750                    .into_iter()
6751                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6753            ),
6754            _ => local_var_req_builder.query(&[(
6755                "description__iregex",
6756                &local_var_str
6757                    .into_iter()
6758                    .map(|p| p.to_string())
6759                    .collect::<Vec<String>>()
6760                    .join(",")
6761                    .to_string(),
6762            )]),
6763        };
6764    }
6765    if let Some(ref local_var_str) = description__isw {
6766        local_var_req_builder = match "multi" {
6767            "multi" => local_var_req_builder.query(
6768                &local_var_str
6769                    .into_iter()
6770                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6772            ),
6773            _ => local_var_req_builder.query(&[(
6774                "description__isw",
6775                &local_var_str
6776                    .into_iter()
6777                    .map(|p| p.to_string())
6778                    .collect::<Vec<String>>()
6779                    .join(",")
6780                    .to_string(),
6781            )]),
6782        };
6783    }
6784    if let Some(ref local_var_str) = description__n {
6785        local_var_req_builder = match "multi" {
6786            "multi" => local_var_req_builder.query(
6787                &local_var_str
6788                    .into_iter()
6789                    .map(|p| ("description__n".to_owned(), p.to_string()))
6790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6791            ),
6792            _ => local_var_req_builder.query(&[(
6793                "description__n",
6794                &local_var_str
6795                    .into_iter()
6796                    .map(|p| p.to_string())
6797                    .collect::<Vec<String>>()
6798                    .join(",")
6799                    .to_string(),
6800            )]),
6801        };
6802    }
6803    if let Some(ref local_var_str) = description__nic {
6804        local_var_req_builder = match "multi" {
6805            "multi" => local_var_req_builder.query(
6806                &local_var_str
6807                    .into_iter()
6808                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6810            ),
6811            _ => local_var_req_builder.query(&[(
6812                "description__nic",
6813                &local_var_str
6814                    .into_iter()
6815                    .map(|p| p.to_string())
6816                    .collect::<Vec<String>>()
6817                    .join(",")
6818                    .to_string(),
6819            )]),
6820        };
6821    }
6822    if let Some(ref local_var_str) = description__nie {
6823        local_var_req_builder = match "multi" {
6824            "multi" => local_var_req_builder.query(
6825                &local_var_str
6826                    .into_iter()
6827                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6829            ),
6830            _ => local_var_req_builder.query(&[(
6831                "description__nie",
6832                &local_var_str
6833                    .into_iter()
6834                    .map(|p| p.to_string())
6835                    .collect::<Vec<String>>()
6836                    .join(",")
6837                    .to_string(),
6838            )]),
6839        };
6840    }
6841    if let Some(ref local_var_str) = description__niew {
6842        local_var_req_builder = match "multi" {
6843            "multi" => local_var_req_builder.query(
6844                &local_var_str
6845                    .into_iter()
6846                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6848            ),
6849            _ => local_var_req_builder.query(&[(
6850                "description__niew",
6851                &local_var_str
6852                    .into_iter()
6853                    .map(|p| p.to_string())
6854                    .collect::<Vec<String>>()
6855                    .join(",")
6856                    .to_string(),
6857            )]),
6858        };
6859    }
6860    if let Some(ref local_var_str) = description__nisw {
6861        local_var_req_builder = match "multi" {
6862            "multi" => local_var_req_builder.query(
6863                &local_var_str
6864                    .into_iter()
6865                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6867            ),
6868            _ => local_var_req_builder.query(&[(
6869                "description__nisw",
6870                &local_var_str
6871                    .into_iter()
6872                    .map(|p| p.to_string())
6873                    .collect::<Vec<String>>()
6874                    .join(",")
6875                    .to_string(),
6876            )]),
6877        };
6878    }
6879    if let Some(ref local_var_str) = description__regex {
6880        local_var_req_builder = match "multi" {
6881            "multi" => local_var_req_builder.query(
6882                &local_var_str
6883                    .into_iter()
6884                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6886            ),
6887            _ => local_var_req_builder.query(&[(
6888                "description__regex",
6889                &local_var_str
6890                    .into_iter()
6891                    .map(|p| p.to_string())
6892                    .collect::<Vec<String>>()
6893                    .join(",")
6894                    .to_string(),
6895            )]),
6896        };
6897    }
6898    if let Some(ref local_var_str) = email {
6899        local_var_req_builder = match "multi" {
6900            "multi" => local_var_req_builder.query(
6901                &local_var_str
6902                    .into_iter()
6903                    .map(|p| ("email".to_owned(), p.to_string()))
6904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6905            ),
6906            _ => local_var_req_builder.query(&[(
6907                "email",
6908                &local_var_str
6909                    .into_iter()
6910                    .map(|p| p.to_string())
6911                    .collect::<Vec<String>>()
6912                    .join(",")
6913                    .to_string(),
6914            )]),
6915        };
6916    }
6917    if let Some(ref local_var_str) = email__empty {
6918        local_var_req_builder =
6919            local_var_req_builder.query(&[("email__empty", &local_var_str.to_string())]);
6920    }
6921    if let Some(ref local_var_str) = email__ic {
6922        local_var_req_builder = match "multi" {
6923            "multi" => local_var_req_builder.query(
6924                &local_var_str
6925                    .into_iter()
6926                    .map(|p| ("email__ic".to_owned(), p.to_string()))
6927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6928            ),
6929            _ => local_var_req_builder.query(&[(
6930                "email__ic",
6931                &local_var_str
6932                    .into_iter()
6933                    .map(|p| p.to_string())
6934                    .collect::<Vec<String>>()
6935                    .join(",")
6936                    .to_string(),
6937            )]),
6938        };
6939    }
6940    if let Some(ref local_var_str) = email__ie {
6941        local_var_req_builder = match "multi" {
6942            "multi" => local_var_req_builder.query(
6943                &local_var_str
6944                    .into_iter()
6945                    .map(|p| ("email__ie".to_owned(), p.to_string()))
6946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6947            ),
6948            _ => local_var_req_builder.query(&[(
6949                "email__ie",
6950                &local_var_str
6951                    .into_iter()
6952                    .map(|p| p.to_string())
6953                    .collect::<Vec<String>>()
6954                    .join(",")
6955                    .to_string(),
6956            )]),
6957        };
6958    }
6959    if let Some(ref local_var_str) = email__iew {
6960        local_var_req_builder = match "multi" {
6961            "multi" => local_var_req_builder.query(
6962                &local_var_str
6963                    .into_iter()
6964                    .map(|p| ("email__iew".to_owned(), p.to_string()))
6965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6966            ),
6967            _ => local_var_req_builder.query(&[(
6968                "email__iew",
6969                &local_var_str
6970                    .into_iter()
6971                    .map(|p| p.to_string())
6972                    .collect::<Vec<String>>()
6973                    .join(",")
6974                    .to_string(),
6975            )]),
6976        };
6977    }
6978    if let Some(ref local_var_str) = email__iregex {
6979        local_var_req_builder = match "multi" {
6980            "multi" => local_var_req_builder.query(
6981                &local_var_str
6982                    .into_iter()
6983                    .map(|p| ("email__iregex".to_owned(), p.to_string()))
6984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6985            ),
6986            _ => local_var_req_builder.query(&[(
6987                "email__iregex",
6988                &local_var_str
6989                    .into_iter()
6990                    .map(|p| p.to_string())
6991                    .collect::<Vec<String>>()
6992                    .join(",")
6993                    .to_string(),
6994            )]),
6995        };
6996    }
6997    if let Some(ref local_var_str) = email__isw {
6998        local_var_req_builder = match "multi" {
6999            "multi" => local_var_req_builder.query(
7000                &local_var_str
7001                    .into_iter()
7002                    .map(|p| ("email__isw".to_owned(), p.to_string()))
7003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7004            ),
7005            _ => local_var_req_builder.query(&[(
7006                "email__isw",
7007                &local_var_str
7008                    .into_iter()
7009                    .map(|p| p.to_string())
7010                    .collect::<Vec<String>>()
7011                    .join(",")
7012                    .to_string(),
7013            )]),
7014        };
7015    }
7016    if let Some(ref local_var_str) = email__n {
7017        local_var_req_builder = match "multi" {
7018            "multi" => local_var_req_builder.query(
7019                &local_var_str
7020                    .into_iter()
7021                    .map(|p| ("email__n".to_owned(), p.to_string()))
7022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7023            ),
7024            _ => local_var_req_builder.query(&[(
7025                "email__n",
7026                &local_var_str
7027                    .into_iter()
7028                    .map(|p| p.to_string())
7029                    .collect::<Vec<String>>()
7030                    .join(",")
7031                    .to_string(),
7032            )]),
7033        };
7034    }
7035    if let Some(ref local_var_str) = email__nic {
7036        local_var_req_builder = match "multi" {
7037            "multi" => local_var_req_builder.query(
7038                &local_var_str
7039                    .into_iter()
7040                    .map(|p| ("email__nic".to_owned(), p.to_string()))
7041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7042            ),
7043            _ => local_var_req_builder.query(&[(
7044                "email__nic",
7045                &local_var_str
7046                    .into_iter()
7047                    .map(|p| p.to_string())
7048                    .collect::<Vec<String>>()
7049                    .join(",")
7050                    .to_string(),
7051            )]),
7052        };
7053    }
7054    if let Some(ref local_var_str) = email__nie {
7055        local_var_req_builder = match "multi" {
7056            "multi" => local_var_req_builder.query(
7057                &local_var_str
7058                    .into_iter()
7059                    .map(|p| ("email__nie".to_owned(), p.to_string()))
7060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7061            ),
7062            _ => local_var_req_builder.query(&[(
7063                "email__nie",
7064                &local_var_str
7065                    .into_iter()
7066                    .map(|p| p.to_string())
7067                    .collect::<Vec<String>>()
7068                    .join(",")
7069                    .to_string(),
7070            )]),
7071        };
7072    }
7073    if let Some(ref local_var_str) = email__niew {
7074        local_var_req_builder = match "multi" {
7075            "multi" => local_var_req_builder.query(
7076                &local_var_str
7077                    .into_iter()
7078                    .map(|p| ("email__niew".to_owned(), p.to_string()))
7079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7080            ),
7081            _ => local_var_req_builder.query(&[(
7082                "email__niew",
7083                &local_var_str
7084                    .into_iter()
7085                    .map(|p| p.to_string())
7086                    .collect::<Vec<String>>()
7087                    .join(",")
7088                    .to_string(),
7089            )]),
7090        };
7091    }
7092    if let Some(ref local_var_str) = email__nisw {
7093        local_var_req_builder = match "multi" {
7094            "multi" => local_var_req_builder.query(
7095                &local_var_str
7096                    .into_iter()
7097                    .map(|p| ("email__nisw".to_owned(), p.to_string()))
7098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7099            ),
7100            _ => local_var_req_builder.query(&[(
7101                "email__nisw",
7102                &local_var_str
7103                    .into_iter()
7104                    .map(|p| p.to_string())
7105                    .collect::<Vec<String>>()
7106                    .join(",")
7107                    .to_string(),
7108            )]),
7109        };
7110    }
7111    if let Some(ref local_var_str) = email__regex {
7112        local_var_req_builder = match "multi" {
7113            "multi" => local_var_req_builder.query(
7114                &local_var_str
7115                    .into_iter()
7116                    .map(|p| ("email__regex".to_owned(), p.to_string()))
7117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7118            ),
7119            _ => local_var_req_builder.query(&[(
7120                "email__regex",
7121                &local_var_str
7122                    .into_iter()
7123                    .map(|p| p.to_string())
7124                    .collect::<Vec<String>>()
7125                    .join(",")
7126                    .to_string(),
7127            )]),
7128        };
7129    }
7130    if let Some(ref local_var_str) = group {
7131        local_var_req_builder = match "multi" {
7132            "multi" => local_var_req_builder.query(
7133                &local_var_str
7134                    .into_iter()
7135                    .map(|p| ("group".to_owned(), p.to_string()))
7136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7137            ),
7138            _ => local_var_req_builder.query(&[(
7139                "group",
7140                &local_var_str
7141                    .into_iter()
7142                    .map(|p| p.to_string())
7143                    .collect::<Vec<String>>()
7144                    .join(",")
7145                    .to_string(),
7146            )]),
7147        };
7148    }
7149    if let Some(ref local_var_str) = group__n {
7150        local_var_req_builder = match "multi" {
7151            "multi" => local_var_req_builder.query(
7152                &local_var_str
7153                    .into_iter()
7154                    .map(|p| ("group__n".to_owned(), p.to_string()))
7155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7156            ),
7157            _ => local_var_req_builder.query(&[(
7158                "group__n",
7159                &local_var_str
7160                    .into_iter()
7161                    .map(|p| p.to_string())
7162                    .collect::<Vec<String>>()
7163                    .join(",")
7164                    .to_string(),
7165            )]),
7166        };
7167    }
7168    if let Some(ref local_var_str) = group_id {
7169        local_var_req_builder = match "multi" {
7170            "multi" => local_var_req_builder.query(
7171                &local_var_str
7172                    .into_iter()
7173                    .map(|p| ("group_id".to_owned(), p.to_string()))
7174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7175            ),
7176            _ => local_var_req_builder.query(&[(
7177                "group_id",
7178                &local_var_str
7179                    .into_iter()
7180                    .map(|p| p.to_string())
7181                    .collect::<Vec<String>>()
7182                    .join(",")
7183                    .to_string(),
7184            )]),
7185        };
7186    }
7187    if let Some(ref local_var_str) = group_id__n {
7188        local_var_req_builder = match "multi" {
7189            "multi" => local_var_req_builder.query(
7190                &local_var_str
7191                    .into_iter()
7192                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
7193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7194            ),
7195            _ => local_var_req_builder.query(&[(
7196                "group_id__n",
7197                &local_var_str
7198                    .into_iter()
7199                    .map(|p| p.to_string())
7200                    .collect::<Vec<String>>()
7201                    .join(",")
7202                    .to_string(),
7203            )]),
7204        };
7205    }
7206    if let Some(ref local_var_str) = id {
7207        local_var_req_builder = match "multi" {
7208            "multi" => local_var_req_builder.query(
7209                &local_var_str
7210                    .into_iter()
7211                    .map(|p| ("id".to_owned(), p.to_string()))
7212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7213            ),
7214            _ => local_var_req_builder.query(&[(
7215                "id",
7216                &local_var_str
7217                    .into_iter()
7218                    .map(|p| p.to_string())
7219                    .collect::<Vec<String>>()
7220                    .join(",")
7221                    .to_string(),
7222            )]),
7223        };
7224    }
7225    if let Some(ref local_var_str) = id__empty {
7226        local_var_req_builder =
7227            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7228    }
7229    if let Some(ref local_var_str) = id__gt {
7230        local_var_req_builder = match "multi" {
7231            "multi" => local_var_req_builder.query(
7232                &local_var_str
7233                    .into_iter()
7234                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7236            ),
7237            _ => local_var_req_builder.query(&[(
7238                "id__gt",
7239                &local_var_str
7240                    .into_iter()
7241                    .map(|p| p.to_string())
7242                    .collect::<Vec<String>>()
7243                    .join(",")
7244                    .to_string(),
7245            )]),
7246        };
7247    }
7248    if let Some(ref local_var_str) = id__gte {
7249        local_var_req_builder = match "multi" {
7250            "multi" => local_var_req_builder.query(
7251                &local_var_str
7252                    .into_iter()
7253                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7255            ),
7256            _ => local_var_req_builder.query(&[(
7257                "id__gte",
7258                &local_var_str
7259                    .into_iter()
7260                    .map(|p| p.to_string())
7261                    .collect::<Vec<String>>()
7262                    .join(",")
7263                    .to_string(),
7264            )]),
7265        };
7266    }
7267    if let Some(ref local_var_str) = id__lt {
7268        local_var_req_builder = match "multi" {
7269            "multi" => local_var_req_builder.query(
7270                &local_var_str
7271                    .into_iter()
7272                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7274            ),
7275            _ => local_var_req_builder.query(&[(
7276                "id__lt",
7277                &local_var_str
7278                    .into_iter()
7279                    .map(|p| p.to_string())
7280                    .collect::<Vec<String>>()
7281                    .join(",")
7282                    .to_string(),
7283            )]),
7284        };
7285    }
7286    if let Some(ref local_var_str) = id__lte {
7287        local_var_req_builder = match "multi" {
7288            "multi" => local_var_req_builder.query(
7289                &local_var_str
7290                    .into_iter()
7291                    .map(|p| ("id__lte".to_owned(), p.to_string()))
7292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7293            ),
7294            _ => local_var_req_builder.query(&[(
7295                "id__lte",
7296                &local_var_str
7297                    .into_iter()
7298                    .map(|p| p.to_string())
7299                    .collect::<Vec<String>>()
7300                    .join(",")
7301                    .to_string(),
7302            )]),
7303        };
7304    }
7305    if let Some(ref local_var_str) = id__n {
7306        local_var_req_builder = match "multi" {
7307            "multi" => local_var_req_builder.query(
7308                &local_var_str
7309                    .into_iter()
7310                    .map(|p| ("id__n".to_owned(), p.to_string()))
7311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7312            ),
7313            _ => local_var_req_builder.query(&[(
7314                "id__n",
7315                &local_var_str
7316                    .into_iter()
7317                    .map(|p| p.to_string())
7318                    .collect::<Vec<String>>()
7319                    .join(",")
7320                    .to_string(),
7321            )]),
7322        };
7323    }
7324    if let Some(ref local_var_str) = last_updated {
7325        local_var_req_builder = match "multi" {
7326            "multi" => local_var_req_builder.query(
7327                &local_var_str
7328                    .into_iter()
7329                    .map(|p| ("last_updated".to_owned(), p.to_string()))
7330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7331            ),
7332            _ => local_var_req_builder.query(&[(
7333                "last_updated",
7334                &local_var_str
7335                    .into_iter()
7336                    .map(|p| p.to_string())
7337                    .collect::<Vec<String>>()
7338                    .join(",")
7339                    .to_string(),
7340            )]),
7341        };
7342    }
7343    if let Some(ref local_var_str) = last_updated__empty {
7344        local_var_req_builder = match "multi" {
7345            "multi" => local_var_req_builder.query(
7346                &local_var_str
7347                    .into_iter()
7348                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
7349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7350            ),
7351            _ => local_var_req_builder.query(&[(
7352                "last_updated__empty",
7353                &local_var_str
7354                    .into_iter()
7355                    .map(|p| p.to_string())
7356                    .collect::<Vec<String>>()
7357                    .join(",")
7358                    .to_string(),
7359            )]),
7360        };
7361    }
7362    if let Some(ref local_var_str) = last_updated__gt {
7363        local_var_req_builder = match "multi" {
7364            "multi" => local_var_req_builder.query(
7365                &local_var_str
7366                    .into_iter()
7367                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
7368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7369            ),
7370            _ => local_var_req_builder.query(&[(
7371                "last_updated__gt",
7372                &local_var_str
7373                    .into_iter()
7374                    .map(|p| p.to_string())
7375                    .collect::<Vec<String>>()
7376                    .join(",")
7377                    .to_string(),
7378            )]),
7379        };
7380    }
7381    if let Some(ref local_var_str) = last_updated__gte {
7382        local_var_req_builder = match "multi" {
7383            "multi" => local_var_req_builder.query(
7384                &local_var_str
7385                    .into_iter()
7386                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
7387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7388            ),
7389            _ => local_var_req_builder.query(&[(
7390                "last_updated__gte",
7391                &local_var_str
7392                    .into_iter()
7393                    .map(|p| p.to_string())
7394                    .collect::<Vec<String>>()
7395                    .join(",")
7396                    .to_string(),
7397            )]),
7398        };
7399    }
7400    if let Some(ref local_var_str) = last_updated__lt {
7401        local_var_req_builder = match "multi" {
7402            "multi" => local_var_req_builder.query(
7403                &local_var_str
7404                    .into_iter()
7405                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
7406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7407            ),
7408            _ => local_var_req_builder.query(&[(
7409                "last_updated__lt",
7410                &local_var_str
7411                    .into_iter()
7412                    .map(|p| p.to_string())
7413                    .collect::<Vec<String>>()
7414                    .join(",")
7415                    .to_string(),
7416            )]),
7417        };
7418    }
7419    if let Some(ref local_var_str) = last_updated__lte {
7420        local_var_req_builder = match "multi" {
7421            "multi" => local_var_req_builder.query(
7422                &local_var_str
7423                    .into_iter()
7424                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
7425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7426            ),
7427            _ => local_var_req_builder.query(&[(
7428                "last_updated__lte",
7429                &local_var_str
7430                    .into_iter()
7431                    .map(|p| p.to_string())
7432                    .collect::<Vec<String>>()
7433                    .join(",")
7434                    .to_string(),
7435            )]),
7436        };
7437    }
7438    if let Some(ref local_var_str) = last_updated__n {
7439        local_var_req_builder = match "multi" {
7440            "multi" => local_var_req_builder.query(
7441                &local_var_str
7442                    .into_iter()
7443                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
7444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7445            ),
7446            _ => local_var_req_builder.query(&[(
7447                "last_updated__n",
7448                &local_var_str
7449                    .into_iter()
7450                    .map(|p| p.to_string())
7451                    .collect::<Vec<String>>()
7452                    .join(",")
7453                    .to_string(),
7454            )]),
7455        };
7456    }
7457    if let Some(ref local_var_str) = limit {
7458        local_var_req_builder =
7459            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7460    }
7461    if let Some(ref local_var_str) = link {
7462        local_var_req_builder = match "multi" {
7463            "multi" => local_var_req_builder.query(
7464                &local_var_str
7465                    .into_iter()
7466                    .map(|p| ("link".to_owned(), p.to_string()))
7467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7468            ),
7469            _ => local_var_req_builder.query(&[(
7470                "link",
7471                &local_var_str
7472                    .into_iter()
7473                    .map(|p| p.to_string())
7474                    .collect::<Vec<String>>()
7475                    .join(",")
7476                    .to_string(),
7477            )]),
7478        };
7479    }
7480    if let Some(ref local_var_str) = link__empty {
7481        local_var_req_builder =
7482            local_var_req_builder.query(&[("link__empty", &local_var_str.to_string())]);
7483    }
7484    if let Some(ref local_var_str) = link__ic {
7485        local_var_req_builder = match "multi" {
7486            "multi" => local_var_req_builder.query(
7487                &local_var_str
7488                    .into_iter()
7489                    .map(|p| ("link__ic".to_owned(), p.to_string()))
7490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7491            ),
7492            _ => local_var_req_builder.query(&[(
7493                "link__ic",
7494                &local_var_str
7495                    .into_iter()
7496                    .map(|p| p.to_string())
7497                    .collect::<Vec<String>>()
7498                    .join(",")
7499                    .to_string(),
7500            )]),
7501        };
7502    }
7503    if let Some(ref local_var_str) = link__ie {
7504        local_var_req_builder = match "multi" {
7505            "multi" => local_var_req_builder.query(
7506                &local_var_str
7507                    .into_iter()
7508                    .map(|p| ("link__ie".to_owned(), p.to_string()))
7509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7510            ),
7511            _ => local_var_req_builder.query(&[(
7512                "link__ie",
7513                &local_var_str
7514                    .into_iter()
7515                    .map(|p| p.to_string())
7516                    .collect::<Vec<String>>()
7517                    .join(",")
7518                    .to_string(),
7519            )]),
7520        };
7521    }
7522    if let Some(ref local_var_str) = link__iew {
7523        local_var_req_builder = match "multi" {
7524            "multi" => local_var_req_builder.query(
7525                &local_var_str
7526                    .into_iter()
7527                    .map(|p| ("link__iew".to_owned(), p.to_string()))
7528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7529            ),
7530            _ => local_var_req_builder.query(&[(
7531                "link__iew",
7532                &local_var_str
7533                    .into_iter()
7534                    .map(|p| p.to_string())
7535                    .collect::<Vec<String>>()
7536                    .join(",")
7537                    .to_string(),
7538            )]),
7539        };
7540    }
7541    if let Some(ref local_var_str) = link__iregex {
7542        local_var_req_builder = match "multi" {
7543            "multi" => local_var_req_builder.query(
7544                &local_var_str
7545                    .into_iter()
7546                    .map(|p| ("link__iregex".to_owned(), p.to_string()))
7547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7548            ),
7549            _ => local_var_req_builder.query(&[(
7550                "link__iregex",
7551                &local_var_str
7552                    .into_iter()
7553                    .map(|p| p.to_string())
7554                    .collect::<Vec<String>>()
7555                    .join(",")
7556                    .to_string(),
7557            )]),
7558        };
7559    }
7560    if let Some(ref local_var_str) = link__isw {
7561        local_var_req_builder = match "multi" {
7562            "multi" => local_var_req_builder.query(
7563                &local_var_str
7564                    .into_iter()
7565                    .map(|p| ("link__isw".to_owned(), p.to_string()))
7566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7567            ),
7568            _ => local_var_req_builder.query(&[(
7569                "link__isw",
7570                &local_var_str
7571                    .into_iter()
7572                    .map(|p| p.to_string())
7573                    .collect::<Vec<String>>()
7574                    .join(",")
7575                    .to_string(),
7576            )]),
7577        };
7578    }
7579    if let Some(ref local_var_str) = link__n {
7580        local_var_req_builder = match "multi" {
7581            "multi" => local_var_req_builder.query(
7582                &local_var_str
7583                    .into_iter()
7584                    .map(|p| ("link__n".to_owned(), p.to_string()))
7585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7586            ),
7587            _ => local_var_req_builder.query(&[(
7588                "link__n",
7589                &local_var_str
7590                    .into_iter()
7591                    .map(|p| p.to_string())
7592                    .collect::<Vec<String>>()
7593                    .join(",")
7594                    .to_string(),
7595            )]),
7596        };
7597    }
7598    if let Some(ref local_var_str) = link__nic {
7599        local_var_req_builder = match "multi" {
7600            "multi" => local_var_req_builder.query(
7601                &local_var_str
7602                    .into_iter()
7603                    .map(|p| ("link__nic".to_owned(), p.to_string()))
7604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7605            ),
7606            _ => local_var_req_builder.query(&[(
7607                "link__nic",
7608                &local_var_str
7609                    .into_iter()
7610                    .map(|p| p.to_string())
7611                    .collect::<Vec<String>>()
7612                    .join(",")
7613                    .to_string(),
7614            )]),
7615        };
7616    }
7617    if let Some(ref local_var_str) = link__nie {
7618        local_var_req_builder = match "multi" {
7619            "multi" => local_var_req_builder.query(
7620                &local_var_str
7621                    .into_iter()
7622                    .map(|p| ("link__nie".to_owned(), p.to_string()))
7623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7624            ),
7625            _ => local_var_req_builder.query(&[(
7626                "link__nie",
7627                &local_var_str
7628                    .into_iter()
7629                    .map(|p| p.to_string())
7630                    .collect::<Vec<String>>()
7631                    .join(",")
7632                    .to_string(),
7633            )]),
7634        };
7635    }
7636    if let Some(ref local_var_str) = link__niew {
7637        local_var_req_builder = match "multi" {
7638            "multi" => local_var_req_builder.query(
7639                &local_var_str
7640                    .into_iter()
7641                    .map(|p| ("link__niew".to_owned(), p.to_string()))
7642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7643            ),
7644            _ => local_var_req_builder.query(&[(
7645                "link__niew",
7646                &local_var_str
7647                    .into_iter()
7648                    .map(|p| p.to_string())
7649                    .collect::<Vec<String>>()
7650                    .join(",")
7651                    .to_string(),
7652            )]),
7653        };
7654    }
7655    if let Some(ref local_var_str) = link__nisw {
7656        local_var_req_builder = match "multi" {
7657            "multi" => local_var_req_builder.query(
7658                &local_var_str
7659                    .into_iter()
7660                    .map(|p| ("link__nisw".to_owned(), p.to_string()))
7661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7662            ),
7663            _ => local_var_req_builder.query(&[(
7664                "link__nisw",
7665                &local_var_str
7666                    .into_iter()
7667                    .map(|p| p.to_string())
7668                    .collect::<Vec<String>>()
7669                    .join(",")
7670                    .to_string(),
7671            )]),
7672        };
7673    }
7674    if let Some(ref local_var_str) = link__regex {
7675        local_var_req_builder = match "multi" {
7676            "multi" => local_var_req_builder.query(
7677                &local_var_str
7678                    .into_iter()
7679                    .map(|p| ("link__regex".to_owned(), p.to_string()))
7680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7681            ),
7682            _ => local_var_req_builder.query(&[(
7683                "link__regex",
7684                &local_var_str
7685                    .into_iter()
7686                    .map(|p| p.to_string())
7687                    .collect::<Vec<String>>()
7688                    .join(",")
7689                    .to_string(),
7690            )]),
7691        };
7692    }
7693    if let Some(ref local_var_str) = modified_by_request {
7694        local_var_req_builder =
7695            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
7696    }
7697    if let Some(ref local_var_str) = name {
7698        local_var_req_builder = match "multi" {
7699            "multi" => local_var_req_builder.query(
7700                &local_var_str
7701                    .into_iter()
7702                    .map(|p| ("name".to_owned(), p.to_string()))
7703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7704            ),
7705            _ => local_var_req_builder.query(&[(
7706                "name",
7707                &local_var_str
7708                    .into_iter()
7709                    .map(|p| p.to_string())
7710                    .collect::<Vec<String>>()
7711                    .join(",")
7712                    .to_string(),
7713            )]),
7714        };
7715    }
7716    if let Some(ref local_var_str) = name__empty {
7717        local_var_req_builder =
7718            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
7719    }
7720    if let Some(ref local_var_str) = name__ic {
7721        local_var_req_builder = match "multi" {
7722            "multi" => local_var_req_builder.query(
7723                &local_var_str
7724                    .into_iter()
7725                    .map(|p| ("name__ic".to_owned(), p.to_string()))
7726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7727            ),
7728            _ => local_var_req_builder.query(&[(
7729                "name__ic",
7730                &local_var_str
7731                    .into_iter()
7732                    .map(|p| p.to_string())
7733                    .collect::<Vec<String>>()
7734                    .join(",")
7735                    .to_string(),
7736            )]),
7737        };
7738    }
7739    if let Some(ref local_var_str) = name__ie {
7740        local_var_req_builder = match "multi" {
7741            "multi" => local_var_req_builder.query(
7742                &local_var_str
7743                    .into_iter()
7744                    .map(|p| ("name__ie".to_owned(), p.to_string()))
7745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7746            ),
7747            _ => local_var_req_builder.query(&[(
7748                "name__ie",
7749                &local_var_str
7750                    .into_iter()
7751                    .map(|p| p.to_string())
7752                    .collect::<Vec<String>>()
7753                    .join(",")
7754                    .to_string(),
7755            )]),
7756        };
7757    }
7758    if let Some(ref local_var_str) = name__iew {
7759        local_var_req_builder = match "multi" {
7760            "multi" => local_var_req_builder.query(
7761                &local_var_str
7762                    .into_iter()
7763                    .map(|p| ("name__iew".to_owned(), p.to_string()))
7764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7765            ),
7766            _ => local_var_req_builder.query(&[(
7767                "name__iew",
7768                &local_var_str
7769                    .into_iter()
7770                    .map(|p| p.to_string())
7771                    .collect::<Vec<String>>()
7772                    .join(",")
7773                    .to_string(),
7774            )]),
7775        };
7776    }
7777    if let Some(ref local_var_str) = name__iregex {
7778        local_var_req_builder = match "multi" {
7779            "multi" => local_var_req_builder.query(
7780                &local_var_str
7781                    .into_iter()
7782                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
7783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7784            ),
7785            _ => local_var_req_builder.query(&[(
7786                "name__iregex",
7787                &local_var_str
7788                    .into_iter()
7789                    .map(|p| p.to_string())
7790                    .collect::<Vec<String>>()
7791                    .join(",")
7792                    .to_string(),
7793            )]),
7794        };
7795    }
7796    if let Some(ref local_var_str) = name__isw {
7797        local_var_req_builder = match "multi" {
7798            "multi" => local_var_req_builder.query(
7799                &local_var_str
7800                    .into_iter()
7801                    .map(|p| ("name__isw".to_owned(), p.to_string()))
7802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7803            ),
7804            _ => local_var_req_builder.query(&[(
7805                "name__isw",
7806                &local_var_str
7807                    .into_iter()
7808                    .map(|p| p.to_string())
7809                    .collect::<Vec<String>>()
7810                    .join(",")
7811                    .to_string(),
7812            )]),
7813        };
7814    }
7815    if let Some(ref local_var_str) = name__n {
7816        local_var_req_builder = match "multi" {
7817            "multi" => local_var_req_builder.query(
7818                &local_var_str
7819                    .into_iter()
7820                    .map(|p| ("name__n".to_owned(), p.to_string()))
7821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7822            ),
7823            _ => local_var_req_builder.query(&[(
7824                "name__n",
7825                &local_var_str
7826                    .into_iter()
7827                    .map(|p| p.to_string())
7828                    .collect::<Vec<String>>()
7829                    .join(",")
7830                    .to_string(),
7831            )]),
7832        };
7833    }
7834    if let Some(ref local_var_str) = name__nic {
7835        local_var_req_builder = match "multi" {
7836            "multi" => local_var_req_builder.query(
7837                &local_var_str
7838                    .into_iter()
7839                    .map(|p| ("name__nic".to_owned(), p.to_string()))
7840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7841            ),
7842            _ => local_var_req_builder.query(&[(
7843                "name__nic",
7844                &local_var_str
7845                    .into_iter()
7846                    .map(|p| p.to_string())
7847                    .collect::<Vec<String>>()
7848                    .join(",")
7849                    .to_string(),
7850            )]),
7851        };
7852    }
7853    if let Some(ref local_var_str) = name__nie {
7854        local_var_req_builder = match "multi" {
7855            "multi" => local_var_req_builder.query(
7856                &local_var_str
7857                    .into_iter()
7858                    .map(|p| ("name__nie".to_owned(), p.to_string()))
7859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7860            ),
7861            _ => local_var_req_builder.query(&[(
7862                "name__nie",
7863                &local_var_str
7864                    .into_iter()
7865                    .map(|p| p.to_string())
7866                    .collect::<Vec<String>>()
7867                    .join(",")
7868                    .to_string(),
7869            )]),
7870        };
7871    }
7872    if let Some(ref local_var_str) = name__niew {
7873        local_var_req_builder = match "multi" {
7874            "multi" => local_var_req_builder.query(
7875                &local_var_str
7876                    .into_iter()
7877                    .map(|p| ("name__niew".to_owned(), p.to_string()))
7878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7879            ),
7880            _ => local_var_req_builder.query(&[(
7881                "name__niew",
7882                &local_var_str
7883                    .into_iter()
7884                    .map(|p| p.to_string())
7885                    .collect::<Vec<String>>()
7886                    .join(",")
7887                    .to_string(),
7888            )]),
7889        };
7890    }
7891    if let Some(ref local_var_str) = name__nisw {
7892        local_var_req_builder = match "multi" {
7893            "multi" => local_var_req_builder.query(
7894                &local_var_str
7895                    .into_iter()
7896                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
7897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7898            ),
7899            _ => local_var_req_builder.query(&[(
7900                "name__nisw",
7901                &local_var_str
7902                    .into_iter()
7903                    .map(|p| p.to_string())
7904                    .collect::<Vec<String>>()
7905                    .join(",")
7906                    .to_string(),
7907            )]),
7908        };
7909    }
7910    if let Some(ref local_var_str) = name__regex {
7911        local_var_req_builder = match "multi" {
7912            "multi" => local_var_req_builder.query(
7913                &local_var_str
7914                    .into_iter()
7915                    .map(|p| ("name__regex".to_owned(), p.to_string()))
7916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7917            ),
7918            _ => local_var_req_builder.query(&[(
7919                "name__regex",
7920                &local_var_str
7921                    .into_iter()
7922                    .map(|p| p.to_string())
7923                    .collect::<Vec<String>>()
7924                    .join(",")
7925                    .to_string(),
7926            )]),
7927        };
7928    }
7929    if let Some(ref local_var_str) = offset {
7930        local_var_req_builder =
7931            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7932    }
7933    if let Some(ref local_var_str) = ordering {
7934        local_var_req_builder =
7935            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
7936    }
7937    if let Some(ref local_var_str) = owner {
7938        local_var_req_builder = match "multi" {
7939            "multi" => local_var_req_builder.query(
7940                &local_var_str
7941                    .into_iter()
7942                    .map(|p| ("owner".to_owned(), p.to_string()))
7943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7944            ),
7945            _ => local_var_req_builder.query(&[(
7946                "owner",
7947                &local_var_str
7948                    .into_iter()
7949                    .map(|p| p.to_string())
7950                    .collect::<Vec<String>>()
7951                    .join(",")
7952                    .to_string(),
7953            )]),
7954        };
7955    }
7956    if let Some(ref local_var_str) = owner__n {
7957        local_var_req_builder = match "multi" {
7958            "multi" => local_var_req_builder.query(
7959                &local_var_str
7960                    .into_iter()
7961                    .map(|p| ("owner__n".to_owned(), p.to_string()))
7962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7963            ),
7964            _ => local_var_req_builder.query(&[(
7965                "owner__n",
7966                &local_var_str
7967                    .into_iter()
7968                    .map(|p| p.to_string())
7969                    .collect::<Vec<String>>()
7970                    .join(",")
7971                    .to_string(),
7972            )]),
7973        };
7974    }
7975    if let Some(ref local_var_str) = owner_group {
7976        local_var_req_builder = match "multi" {
7977            "multi" => local_var_req_builder.query(
7978                &local_var_str
7979                    .into_iter()
7980                    .map(|p| ("owner_group".to_owned(), p.to_string()))
7981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7982            ),
7983            _ => local_var_req_builder.query(&[(
7984                "owner_group",
7985                &local_var_str
7986                    .into_iter()
7987                    .map(|p| p.to_string())
7988                    .collect::<Vec<String>>()
7989                    .join(",")
7990                    .to_string(),
7991            )]),
7992        };
7993    }
7994    if let Some(ref local_var_str) = owner_group__n {
7995        local_var_req_builder = match "multi" {
7996            "multi" => local_var_req_builder.query(
7997                &local_var_str
7998                    .into_iter()
7999                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
8000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8001            ),
8002            _ => local_var_req_builder.query(&[(
8003                "owner_group__n",
8004                &local_var_str
8005                    .into_iter()
8006                    .map(|p| p.to_string())
8007                    .collect::<Vec<String>>()
8008                    .join(",")
8009                    .to_string(),
8010            )]),
8011        };
8012    }
8013    if let Some(ref local_var_str) = owner_group_id {
8014        local_var_req_builder = match "multi" {
8015            "multi" => local_var_req_builder.query(
8016                &local_var_str
8017                    .into_iter()
8018                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
8019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8020            ),
8021            _ => local_var_req_builder.query(&[(
8022                "owner_group_id",
8023                &local_var_str
8024                    .into_iter()
8025                    .map(|p| p.to_string())
8026                    .collect::<Vec<String>>()
8027                    .join(",")
8028                    .to_string(),
8029            )]),
8030        };
8031    }
8032    if let Some(ref local_var_str) = owner_group_id__n {
8033        local_var_req_builder = match "multi" {
8034            "multi" => local_var_req_builder.query(
8035                &local_var_str
8036                    .into_iter()
8037                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
8038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8039            ),
8040            _ => local_var_req_builder.query(&[(
8041                "owner_group_id__n",
8042                &local_var_str
8043                    .into_iter()
8044                    .map(|p| p.to_string())
8045                    .collect::<Vec<String>>()
8046                    .join(",")
8047                    .to_string(),
8048            )]),
8049        };
8050    }
8051    if let Some(ref local_var_str) = owner_id {
8052        local_var_req_builder = match "multi" {
8053            "multi" => local_var_req_builder.query(
8054                &local_var_str
8055                    .into_iter()
8056                    .map(|p| ("owner_id".to_owned(), p.to_string()))
8057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8058            ),
8059            _ => local_var_req_builder.query(&[(
8060                "owner_id",
8061                &local_var_str
8062                    .into_iter()
8063                    .map(|p| p.to_string())
8064                    .collect::<Vec<String>>()
8065                    .join(",")
8066                    .to_string(),
8067            )]),
8068        };
8069    }
8070    if let Some(ref local_var_str) = owner_id__n {
8071        local_var_req_builder = match "multi" {
8072            "multi" => local_var_req_builder.query(
8073                &local_var_str
8074                    .into_iter()
8075                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
8076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8077            ),
8078            _ => local_var_req_builder.query(&[(
8079                "owner_id__n",
8080                &local_var_str
8081                    .into_iter()
8082                    .map(|p| p.to_string())
8083                    .collect::<Vec<String>>()
8084                    .join(",")
8085                    .to_string(),
8086            )]),
8087        };
8088    }
8089    if let Some(ref local_var_str) = phone {
8090        local_var_req_builder = match "multi" {
8091            "multi" => local_var_req_builder.query(
8092                &local_var_str
8093                    .into_iter()
8094                    .map(|p| ("phone".to_owned(), p.to_string()))
8095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8096            ),
8097            _ => local_var_req_builder.query(&[(
8098                "phone",
8099                &local_var_str
8100                    .into_iter()
8101                    .map(|p| p.to_string())
8102                    .collect::<Vec<String>>()
8103                    .join(",")
8104                    .to_string(),
8105            )]),
8106        };
8107    }
8108    if let Some(ref local_var_str) = phone__empty {
8109        local_var_req_builder =
8110            local_var_req_builder.query(&[("phone__empty", &local_var_str.to_string())]);
8111    }
8112    if let Some(ref local_var_str) = phone__ic {
8113        local_var_req_builder = match "multi" {
8114            "multi" => local_var_req_builder.query(
8115                &local_var_str
8116                    .into_iter()
8117                    .map(|p| ("phone__ic".to_owned(), p.to_string()))
8118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8119            ),
8120            _ => local_var_req_builder.query(&[(
8121                "phone__ic",
8122                &local_var_str
8123                    .into_iter()
8124                    .map(|p| p.to_string())
8125                    .collect::<Vec<String>>()
8126                    .join(",")
8127                    .to_string(),
8128            )]),
8129        };
8130    }
8131    if let Some(ref local_var_str) = phone__ie {
8132        local_var_req_builder = match "multi" {
8133            "multi" => local_var_req_builder.query(
8134                &local_var_str
8135                    .into_iter()
8136                    .map(|p| ("phone__ie".to_owned(), p.to_string()))
8137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8138            ),
8139            _ => local_var_req_builder.query(&[(
8140                "phone__ie",
8141                &local_var_str
8142                    .into_iter()
8143                    .map(|p| p.to_string())
8144                    .collect::<Vec<String>>()
8145                    .join(",")
8146                    .to_string(),
8147            )]),
8148        };
8149    }
8150    if let Some(ref local_var_str) = phone__iew {
8151        local_var_req_builder = match "multi" {
8152            "multi" => local_var_req_builder.query(
8153                &local_var_str
8154                    .into_iter()
8155                    .map(|p| ("phone__iew".to_owned(), p.to_string()))
8156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8157            ),
8158            _ => local_var_req_builder.query(&[(
8159                "phone__iew",
8160                &local_var_str
8161                    .into_iter()
8162                    .map(|p| p.to_string())
8163                    .collect::<Vec<String>>()
8164                    .join(",")
8165                    .to_string(),
8166            )]),
8167        };
8168    }
8169    if let Some(ref local_var_str) = phone__iregex {
8170        local_var_req_builder = match "multi" {
8171            "multi" => local_var_req_builder.query(
8172                &local_var_str
8173                    .into_iter()
8174                    .map(|p| ("phone__iregex".to_owned(), p.to_string()))
8175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8176            ),
8177            _ => local_var_req_builder.query(&[(
8178                "phone__iregex",
8179                &local_var_str
8180                    .into_iter()
8181                    .map(|p| p.to_string())
8182                    .collect::<Vec<String>>()
8183                    .join(",")
8184                    .to_string(),
8185            )]),
8186        };
8187    }
8188    if let Some(ref local_var_str) = phone__isw {
8189        local_var_req_builder = match "multi" {
8190            "multi" => local_var_req_builder.query(
8191                &local_var_str
8192                    .into_iter()
8193                    .map(|p| ("phone__isw".to_owned(), p.to_string()))
8194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8195            ),
8196            _ => local_var_req_builder.query(&[(
8197                "phone__isw",
8198                &local_var_str
8199                    .into_iter()
8200                    .map(|p| p.to_string())
8201                    .collect::<Vec<String>>()
8202                    .join(",")
8203                    .to_string(),
8204            )]),
8205        };
8206    }
8207    if let Some(ref local_var_str) = phone__n {
8208        local_var_req_builder = match "multi" {
8209            "multi" => local_var_req_builder.query(
8210                &local_var_str
8211                    .into_iter()
8212                    .map(|p| ("phone__n".to_owned(), p.to_string()))
8213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8214            ),
8215            _ => local_var_req_builder.query(&[(
8216                "phone__n",
8217                &local_var_str
8218                    .into_iter()
8219                    .map(|p| p.to_string())
8220                    .collect::<Vec<String>>()
8221                    .join(",")
8222                    .to_string(),
8223            )]),
8224        };
8225    }
8226    if let Some(ref local_var_str) = phone__nic {
8227        local_var_req_builder = match "multi" {
8228            "multi" => local_var_req_builder.query(
8229                &local_var_str
8230                    .into_iter()
8231                    .map(|p| ("phone__nic".to_owned(), p.to_string()))
8232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8233            ),
8234            _ => local_var_req_builder.query(&[(
8235                "phone__nic",
8236                &local_var_str
8237                    .into_iter()
8238                    .map(|p| p.to_string())
8239                    .collect::<Vec<String>>()
8240                    .join(",")
8241                    .to_string(),
8242            )]),
8243        };
8244    }
8245    if let Some(ref local_var_str) = phone__nie {
8246        local_var_req_builder = match "multi" {
8247            "multi" => local_var_req_builder.query(
8248                &local_var_str
8249                    .into_iter()
8250                    .map(|p| ("phone__nie".to_owned(), p.to_string()))
8251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8252            ),
8253            _ => local_var_req_builder.query(&[(
8254                "phone__nie",
8255                &local_var_str
8256                    .into_iter()
8257                    .map(|p| p.to_string())
8258                    .collect::<Vec<String>>()
8259                    .join(",")
8260                    .to_string(),
8261            )]),
8262        };
8263    }
8264    if let Some(ref local_var_str) = phone__niew {
8265        local_var_req_builder = match "multi" {
8266            "multi" => local_var_req_builder.query(
8267                &local_var_str
8268                    .into_iter()
8269                    .map(|p| ("phone__niew".to_owned(), p.to_string()))
8270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8271            ),
8272            _ => local_var_req_builder.query(&[(
8273                "phone__niew",
8274                &local_var_str
8275                    .into_iter()
8276                    .map(|p| p.to_string())
8277                    .collect::<Vec<String>>()
8278                    .join(",")
8279                    .to_string(),
8280            )]),
8281        };
8282    }
8283    if let Some(ref local_var_str) = phone__nisw {
8284        local_var_req_builder = match "multi" {
8285            "multi" => local_var_req_builder.query(
8286                &local_var_str
8287                    .into_iter()
8288                    .map(|p| ("phone__nisw".to_owned(), p.to_string()))
8289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8290            ),
8291            _ => local_var_req_builder.query(&[(
8292                "phone__nisw",
8293                &local_var_str
8294                    .into_iter()
8295                    .map(|p| p.to_string())
8296                    .collect::<Vec<String>>()
8297                    .join(",")
8298                    .to_string(),
8299            )]),
8300        };
8301    }
8302    if let Some(ref local_var_str) = phone__regex {
8303        local_var_req_builder = match "multi" {
8304            "multi" => local_var_req_builder.query(
8305                &local_var_str
8306                    .into_iter()
8307                    .map(|p| ("phone__regex".to_owned(), p.to_string()))
8308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8309            ),
8310            _ => local_var_req_builder.query(&[(
8311                "phone__regex",
8312                &local_var_str
8313                    .into_iter()
8314                    .map(|p| p.to_string())
8315                    .collect::<Vec<String>>()
8316                    .join(",")
8317                    .to_string(),
8318            )]),
8319        };
8320    }
8321    if let Some(ref local_var_str) = q {
8322        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8323    }
8324    if let Some(ref local_var_str) = tag {
8325        local_var_req_builder = match "multi" {
8326            "multi" => local_var_req_builder.query(
8327                &local_var_str
8328                    .into_iter()
8329                    .map(|p| ("tag".to_owned(), p.to_string()))
8330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8331            ),
8332            _ => local_var_req_builder.query(&[(
8333                "tag",
8334                &local_var_str
8335                    .into_iter()
8336                    .map(|p| p.to_string())
8337                    .collect::<Vec<String>>()
8338                    .join(",")
8339                    .to_string(),
8340            )]),
8341        };
8342    }
8343    if let Some(ref local_var_str) = tag__n {
8344        local_var_req_builder = match "multi" {
8345            "multi" => local_var_req_builder.query(
8346                &local_var_str
8347                    .into_iter()
8348                    .map(|p| ("tag__n".to_owned(), p.to_string()))
8349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8350            ),
8351            _ => local_var_req_builder.query(&[(
8352                "tag__n",
8353                &local_var_str
8354                    .into_iter()
8355                    .map(|p| p.to_string())
8356                    .collect::<Vec<String>>()
8357                    .join(",")
8358                    .to_string(),
8359            )]),
8360        };
8361    }
8362    if let Some(ref local_var_str) = tag_id {
8363        local_var_req_builder = match "multi" {
8364            "multi" => local_var_req_builder.query(
8365                &local_var_str
8366                    .into_iter()
8367                    .map(|p| ("tag_id".to_owned(), p.to_string()))
8368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8369            ),
8370            _ => local_var_req_builder.query(&[(
8371                "tag_id",
8372                &local_var_str
8373                    .into_iter()
8374                    .map(|p| p.to_string())
8375                    .collect::<Vec<String>>()
8376                    .join(",")
8377                    .to_string(),
8378            )]),
8379        };
8380    }
8381    if let Some(ref local_var_str) = tag_id__n {
8382        local_var_req_builder = match "multi" {
8383            "multi" => local_var_req_builder.query(
8384                &local_var_str
8385                    .into_iter()
8386                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
8387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8388            ),
8389            _ => local_var_req_builder.query(&[(
8390                "tag_id__n",
8391                &local_var_str
8392                    .into_iter()
8393                    .map(|p| p.to_string())
8394                    .collect::<Vec<String>>()
8395                    .join(",")
8396                    .to_string(),
8397            )]),
8398        };
8399    }
8400    if let Some(ref local_var_str) = title {
8401        local_var_req_builder = match "multi" {
8402            "multi" => local_var_req_builder.query(
8403                &local_var_str
8404                    .into_iter()
8405                    .map(|p| ("title".to_owned(), p.to_string()))
8406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8407            ),
8408            _ => local_var_req_builder.query(&[(
8409                "title",
8410                &local_var_str
8411                    .into_iter()
8412                    .map(|p| p.to_string())
8413                    .collect::<Vec<String>>()
8414                    .join(",")
8415                    .to_string(),
8416            )]),
8417        };
8418    }
8419    if let Some(ref local_var_str) = title__empty {
8420        local_var_req_builder =
8421            local_var_req_builder.query(&[("title__empty", &local_var_str.to_string())]);
8422    }
8423    if let Some(ref local_var_str) = title__ic {
8424        local_var_req_builder = match "multi" {
8425            "multi" => local_var_req_builder.query(
8426                &local_var_str
8427                    .into_iter()
8428                    .map(|p| ("title__ic".to_owned(), p.to_string()))
8429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8430            ),
8431            _ => local_var_req_builder.query(&[(
8432                "title__ic",
8433                &local_var_str
8434                    .into_iter()
8435                    .map(|p| p.to_string())
8436                    .collect::<Vec<String>>()
8437                    .join(",")
8438                    .to_string(),
8439            )]),
8440        };
8441    }
8442    if let Some(ref local_var_str) = title__ie {
8443        local_var_req_builder = match "multi" {
8444            "multi" => local_var_req_builder.query(
8445                &local_var_str
8446                    .into_iter()
8447                    .map(|p| ("title__ie".to_owned(), p.to_string()))
8448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8449            ),
8450            _ => local_var_req_builder.query(&[(
8451                "title__ie",
8452                &local_var_str
8453                    .into_iter()
8454                    .map(|p| p.to_string())
8455                    .collect::<Vec<String>>()
8456                    .join(",")
8457                    .to_string(),
8458            )]),
8459        };
8460    }
8461    if let Some(ref local_var_str) = title__iew {
8462        local_var_req_builder = match "multi" {
8463            "multi" => local_var_req_builder.query(
8464                &local_var_str
8465                    .into_iter()
8466                    .map(|p| ("title__iew".to_owned(), p.to_string()))
8467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8468            ),
8469            _ => local_var_req_builder.query(&[(
8470                "title__iew",
8471                &local_var_str
8472                    .into_iter()
8473                    .map(|p| p.to_string())
8474                    .collect::<Vec<String>>()
8475                    .join(",")
8476                    .to_string(),
8477            )]),
8478        };
8479    }
8480    if let Some(ref local_var_str) = title__iregex {
8481        local_var_req_builder = match "multi" {
8482            "multi" => local_var_req_builder.query(
8483                &local_var_str
8484                    .into_iter()
8485                    .map(|p| ("title__iregex".to_owned(), p.to_string()))
8486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8487            ),
8488            _ => local_var_req_builder.query(&[(
8489                "title__iregex",
8490                &local_var_str
8491                    .into_iter()
8492                    .map(|p| p.to_string())
8493                    .collect::<Vec<String>>()
8494                    .join(",")
8495                    .to_string(),
8496            )]),
8497        };
8498    }
8499    if let Some(ref local_var_str) = title__isw {
8500        local_var_req_builder = match "multi" {
8501            "multi" => local_var_req_builder.query(
8502                &local_var_str
8503                    .into_iter()
8504                    .map(|p| ("title__isw".to_owned(), p.to_string()))
8505                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8506            ),
8507            _ => local_var_req_builder.query(&[(
8508                "title__isw",
8509                &local_var_str
8510                    .into_iter()
8511                    .map(|p| p.to_string())
8512                    .collect::<Vec<String>>()
8513                    .join(",")
8514                    .to_string(),
8515            )]),
8516        };
8517    }
8518    if let Some(ref local_var_str) = title__n {
8519        local_var_req_builder = match "multi" {
8520            "multi" => local_var_req_builder.query(
8521                &local_var_str
8522                    .into_iter()
8523                    .map(|p| ("title__n".to_owned(), p.to_string()))
8524                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8525            ),
8526            _ => local_var_req_builder.query(&[(
8527                "title__n",
8528                &local_var_str
8529                    .into_iter()
8530                    .map(|p| p.to_string())
8531                    .collect::<Vec<String>>()
8532                    .join(",")
8533                    .to_string(),
8534            )]),
8535        };
8536    }
8537    if let Some(ref local_var_str) = title__nic {
8538        local_var_req_builder = match "multi" {
8539            "multi" => local_var_req_builder.query(
8540                &local_var_str
8541                    .into_iter()
8542                    .map(|p| ("title__nic".to_owned(), p.to_string()))
8543                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8544            ),
8545            _ => local_var_req_builder.query(&[(
8546                "title__nic",
8547                &local_var_str
8548                    .into_iter()
8549                    .map(|p| p.to_string())
8550                    .collect::<Vec<String>>()
8551                    .join(",")
8552                    .to_string(),
8553            )]),
8554        };
8555    }
8556    if let Some(ref local_var_str) = title__nie {
8557        local_var_req_builder = match "multi" {
8558            "multi" => local_var_req_builder.query(
8559                &local_var_str
8560                    .into_iter()
8561                    .map(|p| ("title__nie".to_owned(), p.to_string()))
8562                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8563            ),
8564            _ => local_var_req_builder.query(&[(
8565                "title__nie",
8566                &local_var_str
8567                    .into_iter()
8568                    .map(|p| p.to_string())
8569                    .collect::<Vec<String>>()
8570                    .join(",")
8571                    .to_string(),
8572            )]),
8573        };
8574    }
8575    if let Some(ref local_var_str) = title__niew {
8576        local_var_req_builder = match "multi" {
8577            "multi" => local_var_req_builder.query(
8578                &local_var_str
8579                    .into_iter()
8580                    .map(|p| ("title__niew".to_owned(), p.to_string()))
8581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8582            ),
8583            _ => local_var_req_builder.query(&[(
8584                "title__niew",
8585                &local_var_str
8586                    .into_iter()
8587                    .map(|p| p.to_string())
8588                    .collect::<Vec<String>>()
8589                    .join(",")
8590                    .to_string(),
8591            )]),
8592        };
8593    }
8594    if let Some(ref local_var_str) = title__nisw {
8595        local_var_req_builder = match "multi" {
8596            "multi" => local_var_req_builder.query(
8597                &local_var_str
8598                    .into_iter()
8599                    .map(|p| ("title__nisw".to_owned(), p.to_string()))
8600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8601            ),
8602            _ => local_var_req_builder.query(&[(
8603                "title__nisw",
8604                &local_var_str
8605                    .into_iter()
8606                    .map(|p| p.to_string())
8607                    .collect::<Vec<String>>()
8608                    .join(",")
8609                    .to_string(),
8610            )]),
8611        };
8612    }
8613    if let Some(ref local_var_str) = title__regex {
8614        local_var_req_builder = match "multi" {
8615            "multi" => local_var_req_builder.query(
8616                &local_var_str
8617                    .into_iter()
8618                    .map(|p| ("title__regex".to_owned(), p.to_string()))
8619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8620            ),
8621            _ => local_var_req_builder.query(&[(
8622                "title__regex",
8623                &local_var_str
8624                    .into_iter()
8625                    .map(|p| p.to_string())
8626                    .collect::<Vec<String>>()
8627                    .join(",")
8628                    .to_string(),
8629            )]),
8630        };
8631    }
8632    if let Some(ref local_var_str) = updated_by_request {
8633        local_var_req_builder =
8634            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
8635    }
8636    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8637        local_var_req_builder =
8638            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8639    }
8640    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8641        let local_var_key = local_var_apikey.key.clone();
8642        let local_var_value = match local_var_apikey.prefix {
8643            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8644            None => local_var_key,
8645        };
8646        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8647    };
8648
8649    let local_var_req = local_var_req_builder.build()?;
8650    let local_var_resp = local_var_client.execute(local_var_req).await?;
8651
8652    let local_var_status = local_var_resp.status();
8653    let local_var_content = local_var_resp.text().await?;
8654
8655    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8656        serde_json::from_str(&local_var_content).map_err(Error::from)
8657    } else {
8658        let local_var_entity: Option<TenancyContactsListError> =
8659            serde_json::from_str(&local_var_content).ok();
8660        let local_var_error = ResponseContent {
8661            status: local_var_status,
8662            content: local_var_content,
8663            entity: local_var_entity,
8664        };
8665        Err(Error::ResponseError(local_var_error))
8666    }
8667}
8668
8669/// Patch a contact object.
8670pub async fn tenancy_contacts_partial_update(
8671    configuration: &configuration::Configuration,
8672    id: i32,
8673    patched_contact_request: Option<crate::models::PatchedContactRequest>,
8674) -> Result<crate::models::Contact, Error<TenancyContactsPartialUpdateError>> {
8675    let local_var_configuration = configuration;
8676
8677    let local_var_client = &local_var_configuration.client;
8678
8679    let local_var_uri_str = format!(
8680        "{}/api/tenancy/contacts/{id}/",
8681        local_var_configuration.base_path,
8682        id = id
8683    );
8684    let mut local_var_req_builder =
8685        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8686
8687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8688        local_var_req_builder =
8689            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8690    }
8691    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8692        let local_var_key = local_var_apikey.key.clone();
8693        let local_var_value = match local_var_apikey.prefix {
8694            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8695            None => local_var_key,
8696        };
8697        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8698    };
8699    local_var_req_builder = local_var_req_builder.json(&patched_contact_request);
8700
8701    let local_var_req = local_var_req_builder.build()?;
8702    let local_var_resp = local_var_client.execute(local_var_req).await?;
8703
8704    let local_var_status = local_var_resp.status();
8705    let local_var_content = local_var_resp.text().await?;
8706
8707    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8708        serde_json::from_str(&local_var_content).map_err(Error::from)
8709    } else {
8710        let local_var_entity: Option<TenancyContactsPartialUpdateError> =
8711            serde_json::from_str(&local_var_content).ok();
8712        let local_var_error = ResponseContent {
8713            status: local_var_status,
8714            content: local_var_content,
8715            entity: local_var_entity,
8716        };
8717        Err(Error::ResponseError(local_var_error))
8718    }
8719}
8720
8721/// Get a contact object.
8722pub async fn tenancy_contacts_retrieve(
8723    configuration: &configuration::Configuration,
8724    id: i32,
8725) -> Result<crate::models::Contact, Error<TenancyContactsRetrieveError>> {
8726    let local_var_configuration = configuration;
8727
8728    let local_var_client = &local_var_configuration.client;
8729
8730    let local_var_uri_str = format!(
8731        "{}/api/tenancy/contacts/{id}/",
8732        local_var_configuration.base_path,
8733        id = id
8734    );
8735    let mut local_var_req_builder =
8736        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8737
8738    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8739        local_var_req_builder =
8740            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8741    }
8742    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8743        let local_var_key = local_var_apikey.key.clone();
8744        let local_var_value = match local_var_apikey.prefix {
8745            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8746            None => local_var_key,
8747        };
8748        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8749    };
8750
8751    let local_var_req = local_var_req_builder.build()?;
8752    let local_var_resp = local_var_client.execute(local_var_req).await?;
8753
8754    let local_var_status = local_var_resp.status();
8755    let local_var_content = local_var_resp.text().await?;
8756
8757    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8758        serde_json::from_str(&local_var_content).map_err(Error::from)
8759    } else {
8760        let local_var_entity: Option<TenancyContactsRetrieveError> =
8761            serde_json::from_str(&local_var_content).ok();
8762        let local_var_error = ResponseContent {
8763            status: local_var_status,
8764            content: local_var_content,
8765            entity: local_var_entity,
8766        };
8767        Err(Error::ResponseError(local_var_error))
8768    }
8769}
8770
8771/// Put a contact object.
8772pub async fn tenancy_contacts_update(
8773    configuration: &configuration::Configuration,
8774    id: i32,
8775    contact_request: crate::models::ContactRequest,
8776) -> Result<crate::models::Contact, Error<TenancyContactsUpdateError>> {
8777    let local_var_configuration = configuration;
8778
8779    let local_var_client = &local_var_configuration.client;
8780
8781    let local_var_uri_str = format!(
8782        "{}/api/tenancy/contacts/{id}/",
8783        local_var_configuration.base_path,
8784        id = id
8785    );
8786    let mut local_var_req_builder =
8787        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8788
8789    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8790        local_var_req_builder =
8791            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8792    }
8793    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8794        let local_var_key = local_var_apikey.key.clone();
8795        let local_var_value = match local_var_apikey.prefix {
8796            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8797            None => local_var_key,
8798        };
8799        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8800    };
8801    local_var_req_builder = local_var_req_builder.json(&contact_request);
8802
8803    let local_var_req = local_var_req_builder.build()?;
8804    let local_var_resp = local_var_client.execute(local_var_req).await?;
8805
8806    let local_var_status = local_var_resp.status();
8807    let local_var_content = local_var_resp.text().await?;
8808
8809    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8810        serde_json::from_str(&local_var_content).map_err(Error::from)
8811    } else {
8812        let local_var_entity: Option<TenancyContactsUpdateError> =
8813            serde_json::from_str(&local_var_content).ok();
8814        let local_var_error = ResponseContent {
8815            status: local_var_status,
8816            content: local_var_content,
8817            entity: local_var_entity,
8818        };
8819        Err(Error::ResponseError(local_var_error))
8820    }
8821}
8822
8823/// Delete a list of tenant group objects.
8824pub async fn tenancy_tenant_groups_bulk_destroy(
8825    configuration: &configuration::Configuration,
8826    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8827) -> Result<(), Error<TenancyTenantGroupsBulkDestroyError>> {
8828    let local_var_configuration = configuration;
8829
8830    let local_var_client = &local_var_configuration.client;
8831
8832    let local_var_uri_str = format!(
8833        "{}/api/tenancy/tenant-groups/",
8834        local_var_configuration.base_path
8835    );
8836    let mut local_var_req_builder =
8837        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8838
8839    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8840        local_var_req_builder =
8841            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8842    }
8843    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8844        let local_var_key = local_var_apikey.key.clone();
8845        let local_var_value = match local_var_apikey.prefix {
8846            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8847            None => local_var_key,
8848        };
8849        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8850    };
8851    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8852
8853    let local_var_req = local_var_req_builder.build()?;
8854    let local_var_resp = local_var_client.execute(local_var_req).await?;
8855
8856    let local_var_status = local_var_resp.status();
8857    let local_var_content = local_var_resp.text().await?;
8858
8859    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8860        Ok(())
8861    } else {
8862        let local_var_entity: Option<TenancyTenantGroupsBulkDestroyError> =
8863            serde_json::from_str(&local_var_content).ok();
8864        let local_var_error = ResponseContent {
8865            status: local_var_status,
8866            content: local_var_content,
8867            entity: local_var_entity,
8868        };
8869        Err(Error::ResponseError(local_var_error))
8870    }
8871}
8872
8873/// Patch a list of tenant group objects.
8874pub async fn tenancy_tenant_groups_bulk_partial_update(
8875    configuration: &configuration::Configuration,
8876    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8877) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkPartialUpdateError>> {
8878    let local_var_configuration = configuration;
8879
8880    let local_var_client = &local_var_configuration.client;
8881
8882    let local_var_uri_str = format!(
8883        "{}/api/tenancy/tenant-groups/",
8884        local_var_configuration.base_path
8885    );
8886    let mut local_var_req_builder =
8887        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8888
8889    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8890        local_var_req_builder =
8891            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8892    }
8893    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8894        let local_var_key = local_var_apikey.key.clone();
8895        let local_var_value = match local_var_apikey.prefix {
8896            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8897            None => local_var_key,
8898        };
8899        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8900    };
8901    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8902
8903    let local_var_req = local_var_req_builder.build()?;
8904    let local_var_resp = local_var_client.execute(local_var_req).await?;
8905
8906    let local_var_status = local_var_resp.status();
8907    let local_var_content = local_var_resp.text().await?;
8908
8909    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8910        serde_json::from_str(&local_var_content).map_err(Error::from)
8911    } else {
8912        let local_var_entity: Option<TenancyTenantGroupsBulkPartialUpdateError> =
8913            serde_json::from_str(&local_var_content).ok();
8914        let local_var_error = ResponseContent {
8915            status: local_var_status,
8916            content: local_var_content,
8917            entity: local_var_entity,
8918        };
8919        Err(Error::ResponseError(local_var_error))
8920    }
8921}
8922
8923/// Put a list of tenant group objects.
8924pub async fn tenancy_tenant_groups_bulk_update(
8925    configuration: &configuration::Configuration,
8926    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8927) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkUpdateError>> {
8928    let local_var_configuration = configuration;
8929
8930    let local_var_client = &local_var_configuration.client;
8931
8932    let local_var_uri_str = format!(
8933        "{}/api/tenancy/tenant-groups/",
8934        local_var_configuration.base_path
8935    );
8936    let mut local_var_req_builder =
8937        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8938
8939    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8940        local_var_req_builder =
8941            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8942    }
8943    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8944        let local_var_key = local_var_apikey.key.clone();
8945        let local_var_value = match local_var_apikey.prefix {
8946            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8947            None => local_var_key,
8948        };
8949        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8950    };
8951    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8952
8953    let local_var_req = local_var_req_builder.build()?;
8954    let local_var_resp = local_var_client.execute(local_var_req).await?;
8955
8956    let local_var_status = local_var_resp.status();
8957    let local_var_content = local_var_resp.text().await?;
8958
8959    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8960        serde_json::from_str(&local_var_content).map_err(Error::from)
8961    } else {
8962        let local_var_entity: Option<TenancyTenantGroupsBulkUpdateError> =
8963            serde_json::from_str(&local_var_content).ok();
8964        let local_var_error = ResponseContent {
8965            status: local_var_status,
8966            content: local_var_content,
8967            entity: local_var_entity,
8968        };
8969        Err(Error::ResponseError(local_var_error))
8970    }
8971}
8972
8973/// Post a list of tenant group objects.
8974pub async fn tenancy_tenant_groups_create(
8975    configuration: &configuration::Configuration,
8976    tenancy_tenant_groups_create_request: crate::models::TenancyTenantGroupsCreateRequest,
8977) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsCreateError>> {
8978    let local_var_configuration = configuration;
8979
8980    let local_var_client = &local_var_configuration.client;
8981
8982    let local_var_uri_str = format!(
8983        "{}/api/tenancy/tenant-groups/",
8984        local_var_configuration.base_path
8985    );
8986    let mut local_var_req_builder =
8987        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8988
8989    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8990        local_var_req_builder =
8991            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8992    }
8993    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8994        let local_var_key = local_var_apikey.key.clone();
8995        let local_var_value = match local_var_apikey.prefix {
8996            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8997            None => local_var_key,
8998        };
8999        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9000    };
9001    local_var_req_builder = local_var_req_builder.json(&tenancy_tenant_groups_create_request);
9002
9003    let local_var_req = local_var_req_builder.build()?;
9004    let local_var_resp = local_var_client.execute(local_var_req).await?;
9005
9006    let local_var_status = local_var_resp.status();
9007    let local_var_content = local_var_resp.text().await?;
9008
9009    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9010        serde_json::from_str(&local_var_content).map_err(Error::from)
9011    } else {
9012        let local_var_entity: Option<TenancyTenantGroupsCreateError> =
9013            serde_json::from_str(&local_var_content).ok();
9014        let local_var_error = ResponseContent {
9015            status: local_var_status,
9016            content: local_var_content,
9017            entity: local_var_entity,
9018        };
9019        Err(Error::ResponseError(local_var_error))
9020    }
9021}
9022
9023/// Delete a tenant group object.
9024pub async fn tenancy_tenant_groups_destroy(
9025    configuration: &configuration::Configuration,
9026    id: i32,
9027) -> Result<(), Error<TenancyTenantGroupsDestroyError>> {
9028    let local_var_configuration = configuration;
9029
9030    let local_var_client = &local_var_configuration.client;
9031
9032    let local_var_uri_str = format!(
9033        "{}/api/tenancy/tenant-groups/{id}/",
9034        local_var_configuration.base_path,
9035        id = id
9036    );
9037    let mut local_var_req_builder =
9038        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9039
9040    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9041        local_var_req_builder =
9042            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9043    }
9044    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9045        let local_var_key = local_var_apikey.key.clone();
9046        let local_var_value = match local_var_apikey.prefix {
9047            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9048            None => local_var_key,
9049        };
9050        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9051    };
9052
9053    let local_var_req = local_var_req_builder.build()?;
9054    let local_var_resp = local_var_client.execute(local_var_req).await?;
9055
9056    let local_var_status = local_var_resp.status();
9057    let local_var_content = local_var_resp.text().await?;
9058
9059    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9060        Ok(())
9061    } else {
9062        let local_var_entity: Option<TenancyTenantGroupsDestroyError> =
9063            serde_json::from_str(&local_var_content).ok();
9064        let local_var_error = ResponseContent {
9065            status: local_var_status,
9066            content: local_var_content,
9067            entity: local_var_entity,
9068        };
9069        Err(Error::ResponseError(local_var_error))
9070    }
9071}
9072
9073/// Get a list of tenant group objects.
9074pub async fn tenancy_tenant_groups_list(
9075    configuration: &configuration::Configuration,
9076    ancestor: Option<Vec<String>>,
9077    ancestor__n: Option<Vec<String>>,
9078    ancestor_id: Option<Vec<String>>,
9079    ancestor_id__n: Option<Vec<String>>,
9080    created: Option<Vec<String>>,
9081    created__empty: Option<Vec<String>>,
9082    created__gt: Option<Vec<String>>,
9083    created__gte: Option<Vec<String>>,
9084    created__lt: Option<Vec<String>>,
9085    created__lte: Option<Vec<String>>,
9086    created__n: Option<Vec<String>>,
9087    created_by_request: Option<&str>,
9088    description: Option<Vec<String>>,
9089    description__empty: Option<bool>,
9090    description__ic: Option<Vec<String>>,
9091    description__ie: Option<Vec<String>>,
9092    description__iew: Option<Vec<String>>,
9093    description__iregex: Option<Vec<String>>,
9094    description__isw: Option<Vec<String>>,
9095    description__n: Option<Vec<String>>,
9096    description__nic: Option<Vec<String>>,
9097    description__nie: Option<Vec<String>>,
9098    description__niew: Option<Vec<String>>,
9099    description__nisw: Option<Vec<String>>,
9100    description__regex: Option<Vec<String>>,
9101    id: Option<Vec<i32>>,
9102    id__empty: Option<bool>,
9103    id__gt: Option<Vec<i32>>,
9104    id__gte: Option<Vec<i32>>,
9105    id__lt: Option<Vec<i32>>,
9106    id__lte: Option<Vec<i32>>,
9107    id__n: Option<Vec<i32>>,
9108    last_updated: Option<Vec<String>>,
9109    last_updated__empty: Option<Vec<String>>,
9110    last_updated__gt: Option<Vec<String>>,
9111    last_updated__gte: Option<Vec<String>>,
9112    last_updated__lt: Option<Vec<String>>,
9113    last_updated__lte: Option<Vec<String>>,
9114    last_updated__n: Option<Vec<String>>,
9115    limit: Option<i32>,
9116    modified_by_request: Option<&str>,
9117    name: Option<Vec<String>>,
9118    name__empty: Option<bool>,
9119    name__ic: Option<Vec<String>>,
9120    name__ie: Option<Vec<String>>,
9121    name__iew: Option<Vec<String>>,
9122    name__iregex: Option<Vec<String>>,
9123    name__isw: Option<Vec<String>>,
9124    name__n: Option<Vec<String>>,
9125    name__nic: Option<Vec<String>>,
9126    name__nie: Option<Vec<String>>,
9127    name__niew: Option<Vec<String>>,
9128    name__nisw: Option<Vec<String>>,
9129    name__regex: Option<Vec<String>>,
9130    offset: Option<i32>,
9131    ordering: Option<&str>,
9132    owner: Option<Vec<String>>,
9133    owner__n: Option<Vec<String>>,
9134    owner_group: Option<Vec<String>>,
9135    owner_group__n: Option<Vec<String>>,
9136    owner_group_id: Option<Vec<i32>>,
9137    owner_group_id__n: Option<Vec<i32>>,
9138    owner_id: Option<Vec<i32>>,
9139    owner_id__n: Option<Vec<i32>>,
9140    parent: Option<Vec<String>>,
9141    parent__n: Option<Vec<String>>,
9142    parent_id: Option<Vec<i32>>,
9143    parent_id__n: Option<Vec<i32>>,
9144    q: Option<&str>,
9145    slug: Option<Vec<String>>,
9146    slug__empty: Option<bool>,
9147    slug__ic: Option<Vec<String>>,
9148    slug__ie: Option<Vec<String>>,
9149    slug__iew: Option<Vec<String>>,
9150    slug__iregex: Option<Vec<String>>,
9151    slug__isw: Option<Vec<String>>,
9152    slug__n: Option<Vec<String>>,
9153    slug__nic: Option<Vec<String>>,
9154    slug__nie: Option<Vec<String>>,
9155    slug__niew: Option<Vec<String>>,
9156    slug__nisw: Option<Vec<String>>,
9157    slug__regex: Option<Vec<String>>,
9158    tag: Option<Vec<String>>,
9159    tag__n: Option<Vec<String>>,
9160    tag_id: Option<Vec<i32>>,
9161    tag_id__n: Option<Vec<i32>>,
9162    updated_by_request: Option<&str>,
9163) -> Result<crate::models::PaginatedTenantGroupList, Error<TenancyTenantGroupsListError>> {
9164    let local_var_configuration = configuration;
9165
9166    let local_var_client = &local_var_configuration.client;
9167
9168    let local_var_uri_str = format!(
9169        "{}/api/tenancy/tenant-groups/",
9170        local_var_configuration.base_path
9171    );
9172    let mut local_var_req_builder =
9173        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9174
9175    if let Some(ref local_var_str) = ancestor {
9176        local_var_req_builder = match "multi" {
9177            "multi" => local_var_req_builder.query(
9178                &local_var_str
9179                    .into_iter()
9180                    .map(|p| ("ancestor".to_owned(), p.to_string()))
9181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9182            ),
9183            _ => local_var_req_builder.query(&[(
9184                "ancestor",
9185                &local_var_str
9186                    .into_iter()
9187                    .map(|p| p.to_string())
9188                    .collect::<Vec<String>>()
9189                    .join(",")
9190                    .to_string(),
9191            )]),
9192        };
9193    }
9194    if let Some(ref local_var_str) = ancestor__n {
9195        local_var_req_builder = match "multi" {
9196            "multi" => local_var_req_builder.query(
9197                &local_var_str
9198                    .into_iter()
9199                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
9200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9201            ),
9202            _ => local_var_req_builder.query(&[(
9203                "ancestor__n",
9204                &local_var_str
9205                    .into_iter()
9206                    .map(|p| p.to_string())
9207                    .collect::<Vec<String>>()
9208                    .join(",")
9209                    .to_string(),
9210            )]),
9211        };
9212    }
9213    if let Some(ref local_var_str) = ancestor_id {
9214        local_var_req_builder = match "multi" {
9215            "multi" => local_var_req_builder.query(
9216                &local_var_str
9217                    .into_iter()
9218                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
9219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9220            ),
9221            _ => local_var_req_builder.query(&[(
9222                "ancestor_id",
9223                &local_var_str
9224                    .into_iter()
9225                    .map(|p| p.to_string())
9226                    .collect::<Vec<String>>()
9227                    .join(",")
9228                    .to_string(),
9229            )]),
9230        };
9231    }
9232    if let Some(ref local_var_str) = ancestor_id__n {
9233        local_var_req_builder = match "multi" {
9234            "multi" => local_var_req_builder.query(
9235                &local_var_str
9236                    .into_iter()
9237                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
9238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9239            ),
9240            _ => local_var_req_builder.query(&[(
9241                "ancestor_id__n",
9242                &local_var_str
9243                    .into_iter()
9244                    .map(|p| p.to_string())
9245                    .collect::<Vec<String>>()
9246                    .join(",")
9247                    .to_string(),
9248            )]),
9249        };
9250    }
9251    if let Some(ref local_var_str) = created {
9252        local_var_req_builder = match "multi" {
9253            "multi" => local_var_req_builder.query(
9254                &local_var_str
9255                    .into_iter()
9256                    .map(|p| ("created".to_owned(), p.to_string()))
9257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9258            ),
9259            _ => local_var_req_builder.query(&[(
9260                "created",
9261                &local_var_str
9262                    .into_iter()
9263                    .map(|p| p.to_string())
9264                    .collect::<Vec<String>>()
9265                    .join(",")
9266                    .to_string(),
9267            )]),
9268        };
9269    }
9270    if let Some(ref local_var_str) = created__empty {
9271        local_var_req_builder = match "multi" {
9272            "multi" => local_var_req_builder.query(
9273                &local_var_str
9274                    .into_iter()
9275                    .map(|p| ("created__empty".to_owned(), p.to_string()))
9276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9277            ),
9278            _ => local_var_req_builder.query(&[(
9279                "created__empty",
9280                &local_var_str
9281                    .into_iter()
9282                    .map(|p| p.to_string())
9283                    .collect::<Vec<String>>()
9284                    .join(",")
9285                    .to_string(),
9286            )]),
9287        };
9288    }
9289    if let Some(ref local_var_str) = created__gt {
9290        local_var_req_builder = match "multi" {
9291            "multi" => local_var_req_builder.query(
9292                &local_var_str
9293                    .into_iter()
9294                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9296            ),
9297            _ => local_var_req_builder.query(&[(
9298                "created__gt",
9299                &local_var_str
9300                    .into_iter()
9301                    .map(|p| p.to_string())
9302                    .collect::<Vec<String>>()
9303                    .join(",")
9304                    .to_string(),
9305            )]),
9306        };
9307    }
9308    if let Some(ref local_var_str) = created__gte {
9309        local_var_req_builder = match "multi" {
9310            "multi" => local_var_req_builder.query(
9311                &local_var_str
9312                    .into_iter()
9313                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9315            ),
9316            _ => local_var_req_builder.query(&[(
9317                "created__gte",
9318                &local_var_str
9319                    .into_iter()
9320                    .map(|p| p.to_string())
9321                    .collect::<Vec<String>>()
9322                    .join(",")
9323                    .to_string(),
9324            )]),
9325        };
9326    }
9327    if let Some(ref local_var_str) = created__lt {
9328        local_var_req_builder = match "multi" {
9329            "multi" => local_var_req_builder.query(
9330                &local_var_str
9331                    .into_iter()
9332                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9334            ),
9335            _ => local_var_req_builder.query(&[(
9336                "created__lt",
9337                &local_var_str
9338                    .into_iter()
9339                    .map(|p| p.to_string())
9340                    .collect::<Vec<String>>()
9341                    .join(",")
9342                    .to_string(),
9343            )]),
9344        };
9345    }
9346    if let Some(ref local_var_str) = created__lte {
9347        local_var_req_builder = match "multi" {
9348            "multi" => local_var_req_builder.query(
9349                &local_var_str
9350                    .into_iter()
9351                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9353            ),
9354            _ => local_var_req_builder.query(&[(
9355                "created__lte",
9356                &local_var_str
9357                    .into_iter()
9358                    .map(|p| p.to_string())
9359                    .collect::<Vec<String>>()
9360                    .join(",")
9361                    .to_string(),
9362            )]),
9363        };
9364    }
9365    if let Some(ref local_var_str) = created__n {
9366        local_var_req_builder = match "multi" {
9367            "multi" => local_var_req_builder.query(
9368                &local_var_str
9369                    .into_iter()
9370                    .map(|p| ("created__n".to_owned(), p.to_string()))
9371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9372            ),
9373            _ => local_var_req_builder.query(&[(
9374                "created__n",
9375                &local_var_str
9376                    .into_iter()
9377                    .map(|p| p.to_string())
9378                    .collect::<Vec<String>>()
9379                    .join(",")
9380                    .to_string(),
9381            )]),
9382        };
9383    }
9384    if let Some(ref local_var_str) = created_by_request {
9385        local_var_req_builder =
9386            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
9387    }
9388    if let Some(ref local_var_str) = description {
9389        local_var_req_builder = match "multi" {
9390            "multi" => local_var_req_builder.query(
9391                &local_var_str
9392                    .into_iter()
9393                    .map(|p| ("description".to_owned(), p.to_string()))
9394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9395            ),
9396            _ => local_var_req_builder.query(&[(
9397                "description",
9398                &local_var_str
9399                    .into_iter()
9400                    .map(|p| p.to_string())
9401                    .collect::<Vec<String>>()
9402                    .join(",")
9403                    .to_string(),
9404            )]),
9405        };
9406    }
9407    if let Some(ref local_var_str) = description__empty {
9408        local_var_req_builder =
9409            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
9410    }
9411    if let Some(ref local_var_str) = description__ic {
9412        local_var_req_builder = match "multi" {
9413            "multi" => local_var_req_builder.query(
9414                &local_var_str
9415                    .into_iter()
9416                    .map(|p| ("description__ic".to_owned(), p.to_string()))
9417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9418            ),
9419            _ => local_var_req_builder.query(&[(
9420                "description__ic",
9421                &local_var_str
9422                    .into_iter()
9423                    .map(|p| p.to_string())
9424                    .collect::<Vec<String>>()
9425                    .join(",")
9426                    .to_string(),
9427            )]),
9428        };
9429    }
9430    if let Some(ref local_var_str) = description__ie {
9431        local_var_req_builder = match "multi" {
9432            "multi" => local_var_req_builder.query(
9433                &local_var_str
9434                    .into_iter()
9435                    .map(|p| ("description__ie".to_owned(), p.to_string()))
9436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9437            ),
9438            _ => local_var_req_builder.query(&[(
9439                "description__ie",
9440                &local_var_str
9441                    .into_iter()
9442                    .map(|p| p.to_string())
9443                    .collect::<Vec<String>>()
9444                    .join(",")
9445                    .to_string(),
9446            )]),
9447        };
9448    }
9449    if let Some(ref local_var_str) = description__iew {
9450        local_var_req_builder = match "multi" {
9451            "multi" => local_var_req_builder.query(
9452                &local_var_str
9453                    .into_iter()
9454                    .map(|p| ("description__iew".to_owned(), p.to_string()))
9455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9456            ),
9457            _ => local_var_req_builder.query(&[(
9458                "description__iew",
9459                &local_var_str
9460                    .into_iter()
9461                    .map(|p| p.to_string())
9462                    .collect::<Vec<String>>()
9463                    .join(",")
9464                    .to_string(),
9465            )]),
9466        };
9467    }
9468    if let Some(ref local_var_str) = description__iregex {
9469        local_var_req_builder = match "multi" {
9470            "multi" => local_var_req_builder.query(
9471                &local_var_str
9472                    .into_iter()
9473                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
9474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9475            ),
9476            _ => local_var_req_builder.query(&[(
9477                "description__iregex",
9478                &local_var_str
9479                    .into_iter()
9480                    .map(|p| p.to_string())
9481                    .collect::<Vec<String>>()
9482                    .join(",")
9483                    .to_string(),
9484            )]),
9485        };
9486    }
9487    if let Some(ref local_var_str) = description__isw {
9488        local_var_req_builder = match "multi" {
9489            "multi" => local_var_req_builder.query(
9490                &local_var_str
9491                    .into_iter()
9492                    .map(|p| ("description__isw".to_owned(), p.to_string()))
9493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9494            ),
9495            _ => local_var_req_builder.query(&[(
9496                "description__isw",
9497                &local_var_str
9498                    .into_iter()
9499                    .map(|p| p.to_string())
9500                    .collect::<Vec<String>>()
9501                    .join(",")
9502                    .to_string(),
9503            )]),
9504        };
9505    }
9506    if let Some(ref local_var_str) = description__n {
9507        local_var_req_builder = match "multi" {
9508            "multi" => local_var_req_builder.query(
9509                &local_var_str
9510                    .into_iter()
9511                    .map(|p| ("description__n".to_owned(), p.to_string()))
9512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9513            ),
9514            _ => local_var_req_builder.query(&[(
9515                "description__n",
9516                &local_var_str
9517                    .into_iter()
9518                    .map(|p| p.to_string())
9519                    .collect::<Vec<String>>()
9520                    .join(",")
9521                    .to_string(),
9522            )]),
9523        };
9524    }
9525    if let Some(ref local_var_str) = description__nic {
9526        local_var_req_builder = match "multi" {
9527            "multi" => local_var_req_builder.query(
9528                &local_var_str
9529                    .into_iter()
9530                    .map(|p| ("description__nic".to_owned(), p.to_string()))
9531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9532            ),
9533            _ => local_var_req_builder.query(&[(
9534                "description__nic",
9535                &local_var_str
9536                    .into_iter()
9537                    .map(|p| p.to_string())
9538                    .collect::<Vec<String>>()
9539                    .join(",")
9540                    .to_string(),
9541            )]),
9542        };
9543    }
9544    if let Some(ref local_var_str) = description__nie {
9545        local_var_req_builder = match "multi" {
9546            "multi" => local_var_req_builder.query(
9547                &local_var_str
9548                    .into_iter()
9549                    .map(|p| ("description__nie".to_owned(), p.to_string()))
9550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9551            ),
9552            _ => local_var_req_builder.query(&[(
9553                "description__nie",
9554                &local_var_str
9555                    .into_iter()
9556                    .map(|p| p.to_string())
9557                    .collect::<Vec<String>>()
9558                    .join(",")
9559                    .to_string(),
9560            )]),
9561        };
9562    }
9563    if let Some(ref local_var_str) = description__niew {
9564        local_var_req_builder = match "multi" {
9565            "multi" => local_var_req_builder.query(
9566                &local_var_str
9567                    .into_iter()
9568                    .map(|p| ("description__niew".to_owned(), p.to_string()))
9569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9570            ),
9571            _ => local_var_req_builder.query(&[(
9572                "description__niew",
9573                &local_var_str
9574                    .into_iter()
9575                    .map(|p| p.to_string())
9576                    .collect::<Vec<String>>()
9577                    .join(",")
9578                    .to_string(),
9579            )]),
9580        };
9581    }
9582    if let Some(ref local_var_str) = description__nisw {
9583        local_var_req_builder = match "multi" {
9584            "multi" => local_var_req_builder.query(
9585                &local_var_str
9586                    .into_iter()
9587                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
9588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9589            ),
9590            _ => local_var_req_builder.query(&[(
9591                "description__nisw",
9592                &local_var_str
9593                    .into_iter()
9594                    .map(|p| p.to_string())
9595                    .collect::<Vec<String>>()
9596                    .join(",")
9597                    .to_string(),
9598            )]),
9599        };
9600    }
9601    if let Some(ref local_var_str) = description__regex {
9602        local_var_req_builder = match "multi" {
9603            "multi" => local_var_req_builder.query(
9604                &local_var_str
9605                    .into_iter()
9606                    .map(|p| ("description__regex".to_owned(), p.to_string()))
9607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9608            ),
9609            _ => local_var_req_builder.query(&[(
9610                "description__regex",
9611                &local_var_str
9612                    .into_iter()
9613                    .map(|p| p.to_string())
9614                    .collect::<Vec<String>>()
9615                    .join(",")
9616                    .to_string(),
9617            )]),
9618        };
9619    }
9620    if let Some(ref local_var_str) = id {
9621        local_var_req_builder = match "multi" {
9622            "multi" => local_var_req_builder.query(
9623                &local_var_str
9624                    .into_iter()
9625                    .map(|p| ("id".to_owned(), p.to_string()))
9626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9627            ),
9628            _ => local_var_req_builder.query(&[(
9629                "id",
9630                &local_var_str
9631                    .into_iter()
9632                    .map(|p| p.to_string())
9633                    .collect::<Vec<String>>()
9634                    .join(",")
9635                    .to_string(),
9636            )]),
9637        };
9638    }
9639    if let Some(ref local_var_str) = id__empty {
9640        local_var_req_builder =
9641            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
9642    }
9643    if let Some(ref local_var_str) = id__gt {
9644        local_var_req_builder = match "multi" {
9645            "multi" => local_var_req_builder.query(
9646                &local_var_str
9647                    .into_iter()
9648                    .map(|p| ("id__gt".to_owned(), p.to_string()))
9649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9650            ),
9651            _ => local_var_req_builder.query(&[(
9652                "id__gt",
9653                &local_var_str
9654                    .into_iter()
9655                    .map(|p| p.to_string())
9656                    .collect::<Vec<String>>()
9657                    .join(",")
9658                    .to_string(),
9659            )]),
9660        };
9661    }
9662    if let Some(ref local_var_str) = id__gte {
9663        local_var_req_builder = match "multi" {
9664            "multi" => local_var_req_builder.query(
9665                &local_var_str
9666                    .into_iter()
9667                    .map(|p| ("id__gte".to_owned(), p.to_string()))
9668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9669            ),
9670            _ => local_var_req_builder.query(&[(
9671                "id__gte",
9672                &local_var_str
9673                    .into_iter()
9674                    .map(|p| p.to_string())
9675                    .collect::<Vec<String>>()
9676                    .join(",")
9677                    .to_string(),
9678            )]),
9679        };
9680    }
9681    if let Some(ref local_var_str) = id__lt {
9682        local_var_req_builder = match "multi" {
9683            "multi" => local_var_req_builder.query(
9684                &local_var_str
9685                    .into_iter()
9686                    .map(|p| ("id__lt".to_owned(), p.to_string()))
9687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9688            ),
9689            _ => local_var_req_builder.query(&[(
9690                "id__lt",
9691                &local_var_str
9692                    .into_iter()
9693                    .map(|p| p.to_string())
9694                    .collect::<Vec<String>>()
9695                    .join(",")
9696                    .to_string(),
9697            )]),
9698        };
9699    }
9700    if let Some(ref local_var_str) = id__lte {
9701        local_var_req_builder = match "multi" {
9702            "multi" => local_var_req_builder.query(
9703                &local_var_str
9704                    .into_iter()
9705                    .map(|p| ("id__lte".to_owned(), p.to_string()))
9706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9707            ),
9708            _ => local_var_req_builder.query(&[(
9709                "id__lte",
9710                &local_var_str
9711                    .into_iter()
9712                    .map(|p| p.to_string())
9713                    .collect::<Vec<String>>()
9714                    .join(",")
9715                    .to_string(),
9716            )]),
9717        };
9718    }
9719    if let Some(ref local_var_str) = id__n {
9720        local_var_req_builder = match "multi" {
9721            "multi" => local_var_req_builder.query(
9722                &local_var_str
9723                    .into_iter()
9724                    .map(|p| ("id__n".to_owned(), p.to_string()))
9725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9726            ),
9727            _ => local_var_req_builder.query(&[(
9728                "id__n",
9729                &local_var_str
9730                    .into_iter()
9731                    .map(|p| p.to_string())
9732                    .collect::<Vec<String>>()
9733                    .join(",")
9734                    .to_string(),
9735            )]),
9736        };
9737    }
9738    if let Some(ref local_var_str) = last_updated {
9739        local_var_req_builder = match "multi" {
9740            "multi" => local_var_req_builder.query(
9741                &local_var_str
9742                    .into_iter()
9743                    .map(|p| ("last_updated".to_owned(), p.to_string()))
9744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9745            ),
9746            _ => local_var_req_builder.query(&[(
9747                "last_updated",
9748                &local_var_str
9749                    .into_iter()
9750                    .map(|p| p.to_string())
9751                    .collect::<Vec<String>>()
9752                    .join(",")
9753                    .to_string(),
9754            )]),
9755        };
9756    }
9757    if let Some(ref local_var_str) = last_updated__empty {
9758        local_var_req_builder = match "multi" {
9759            "multi" => local_var_req_builder.query(
9760                &local_var_str
9761                    .into_iter()
9762                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
9763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9764            ),
9765            _ => local_var_req_builder.query(&[(
9766                "last_updated__empty",
9767                &local_var_str
9768                    .into_iter()
9769                    .map(|p| p.to_string())
9770                    .collect::<Vec<String>>()
9771                    .join(",")
9772                    .to_string(),
9773            )]),
9774        };
9775    }
9776    if let Some(ref local_var_str) = last_updated__gt {
9777        local_var_req_builder = match "multi" {
9778            "multi" => local_var_req_builder.query(
9779                &local_var_str
9780                    .into_iter()
9781                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
9782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9783            ),
9784            _ => local_var_req_builder.query(&[(
9785                "last_updated__gt",
9786                &local_var_str
9787                    .into_iter()
9788                    .map(|p| p.to_string())
9789                    .collect::<Vec<String>>()
9790                    .join(",")
9791                    .to_string(),
9792            )]),
9793        };
9794    }
9795    if let Some(ref local_var_str) = last_updated__gte {
9796        local_var_req_builder = match "multi" {
9797            "multi" => local_var_req_builder.query(
9798                &local_var_str
9799                    .into_iter()
9800                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
9801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9802            ),
9803            _ => local_var_req_builder.query(&[(
9804                "last_updated__gte",
9805                &local_var_str
9806                    .into_iter()
9807                    .map(|p| p.to_string())
9808                    .collect::<Vec<String>>()
9809                    .join(",")
9810                    .to_string(),
9811            )]),
9812        };
9813    }
9814    if let Some(ref local_var_str) = last_updated__lt {
9815        local_var_req_builder = match "multi" {
9816            "multi" => local_var_req_builder.query(
9817                &local_var_str
9818                    .into_iter()
9819                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
9820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9821            ),
9822            _ => local_var_req_builder.query(&[(
9823                "last_updated__lt",
9824                &local_var_str
9825                    .into_iter()
9826                    .map(|p| p.to_string())
9827                    .collect::<Vec<String>>()
9828                    .join(",")
9829                    .to_string(),
9830            )]),
9831        };
9832    }
9833    if let Some(ref local_var_str) = last_updated__lte {
9834        local_var_req_builder = match "multi" {
9835            "multi" => local_var_req_builder.query(
9836                &local_var_str
9837                    .into_iter()
9838                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
9839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9840            ),
9841            _ => local_var_req_builder.query(&[(
9842                "last_updated__lte",
9843                &local_var_str
9844                    .into_iter()
9845                    .map(|p| p.to_string())
9846                    .collect::<Vec<String>>()
9847                    .join(",")
9848                    .to_string(),
9849            )]),
9850        };
9851    }
9852    if let Some(ref local_var_str) = last_updated__n {
9853        local_var_req_builder = match "multi" {
9854            "multi" => local_var_req_builder.query(
9855                &local_var_str
9856                    .into_iter()
9857                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
9858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9859            ),
9860            _ => local_var_req_builder.query(&[(
9861                "last_updated__n",
9862                &local_var_str
9863                    .into_iter()
9864                    .map(|p| p.to_string())
9865                    .collect::<Vec<String>>()
9866                    .join(",")
9867                    .to_string(),
9868            )]),
9869        };
9870    }
9871    if let Some(ref local_var_str) = limit {
9872        local_var_req_builder =
9873            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9874    }
9875    if let Some(ref local_var_str) = modified_by_request {
9876        local_var_req_builder =
9877            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
9878    }
9879    if let Some(ref local_var_str) = name {
9880        local_var_req_builder = match "multi" {
9881            "multi" => local_var_req_builder.query(
9882                &local_var_str
9883                    .into_iter()
9884                    .map(|p| ("name".to_owned(), p.to_string()))
9885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9886            ),
9887            _ => local_var_req_builder.query(&[(
9888                "name",
9889                &local_var_str
9890                    .into_iter()
9891                    .map(|p| p.to_string())
9892                    .collect::<Vec<String>>()
9893                    .join(",")
9894                    .to_string(),
9895            )]),
9896        };
9897    }
9898    if let Some(ref local_var_str) = name__empty {
9899        local_var_req_builder =
9900            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
9901    }
9902    if let Some(ref local_var_str) = name__ic {
9903        local_var_req_builder = match "multi" {
9904            "multi" => local_var_req_builder.query(
9905                &local_var_str
9906                    .into_iter()
9907                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9909            ),
9910            _ => local_var_req_builder.query(&[(
9911                "name__ic",
9912                &local_var_str
9913                    .into_iter()
9914                    .map(|p| p.to_string())
9915                    .collect::<Vec<String>>()
9916                    .join(",")
9917                    .to_string(),
9918            )]),
9919        };
9920    }
9921    if let Some(ref local_var_str) = name__ie {
9922        local_var_req_builder = match "multi" {
9923            "multi" => local_var_req_builder.query(
9924                &local_var_str
9925                    .into_iter()
9926                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9928            ),
9929            _ => local_var_req_builder.query(&[(
9930                "name__ie",
9931                &local_var_str
9932                    .into_iter()
9933                    .map(|p| p.to_string())
9934                    .collect::<Vec<String>>()
9935                    .join(",")
9936                    .to_string(),
9937            )]),
9938        };
9939    }
9940    if let Some(ref local_var_str) = name__iew {
9941        local_var_req_builder = match "multi" {
9942            "multi" => local_var_req_builder.query(
9943                &local_var_str
9944                    .into_iter()
9945                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9947            ),
9948            _ => local_var_req_builder.query(&[(
9949                "name__iew",
9950                &local_var_str
9951                    .into_iter()
9952                    .map(|p| p.to_string())
9953                    .collect::<Vec<String>>()
9954                    .join(",")
9955                    .to_string(),
9956            )]),
9957        };
9958    }
9959    if let Some(ref local_var_str) = name__iregex {
9960        local_var_req_builder = match "multi" {
9961            "multi" => local_var_req_builder.query(
9962                &local_var_str
9963                    .into_iter()
9964                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9966            ),
9967            _ => local_var_req_builder.query(&[(
9968                "name__iregex",
9969                &local_var_str
9970                    .into_iter()
9971                    .map(|p| p.to_string())
9972                    .collect::<Vec<String>>()
9973                    .join(",")
9974                    .to_string(),
9975            )]),
9976        };
9977    }
9978    if let Some(ref local_var_str) = name__isw {
9979        local_var_req_builder = match "multi" {
9980            "multi" => local_var_req_builder.query(
9981                &local_var_str
9982                    .into_iter()
9983                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9985            ),
9986            _ => local_var_req_builder.query(&[(
9987                "name__isw",
9988                &local_var_str
9989                    .into_iter()
9990                    .map(|p| p.to_string())
9991                    .collect::<Vec<String>>()
9992                    .join(",")
9993                    .to_string(),
9994            )]),
9995        };
9996    }
9997    if let Some(ref local_var_str) = name__n {
9998        local_var_req_builder = match "multi" {
9999            "multi" => local_var_req_builder.query(
10000                &local_var_str
10001                    .into_iter()
10002                    .map(|p| ("name__n".to_owned(), p.to_string()))
10003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10004            ),
10005            _ => local_var_req_builder.query(&[(
10006                "name__n",
10007                &local_var_str
10008                    .into_iter()
10009                    .map(|p| p.to_string())
10010                    .collect::<Vec<String>>()
10011                    .join(",")
10012                    .to_string(),
10013            )]),
10014        };
10015    }
10016    if let Some(ref local_var_str) = name__nic {
10017        local_var_req_builder = match "multi" {
10018            "multi" => local_var_req_builder.query(
10019                &local_var_str
10020                    .into_iter()
10021                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10023            ),
10024            _ => local_var_req_builder.query(&[(
10025                "name__nic",
10026                &local_var_str
10027                    .into_iter()
10028                    .map(|p| p.to_string())
10029                    .collect::<Vec<String>>()
10030                    .join(",")
10031                    .to_string(),
10032            )]),
10033        };
10034    }
10035    if let Some(ref local_var_str) = name__nie {
10036        local_var_req_builder = match "multi" {
10037            "multi" => local_var_req_builder.query(
10038                &local_var_str
10039                    .into_iter()
10040                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10042            ),
10043            _ => local_var_req_builder.query(&[(
10044                "name__nie",
10045                &local_var_str
10046                    .into_iter()
10047                    .map(|p| p.to_string())
10048                    .collect::<Vec<String>>()
10049                    .join(",")
10050                    .to_string(),
10051            )]),
10052        };
10053    }
10054    if let Some(ref local_var_str) = name__niew {
10055        local_var_req_builder = match "multi" {
10056            "multi" => local_var_req_builder.query(
10057                &local_var_str
10058                    .into_iter()
10059                    .map(|p| ("name__niew".to_owned(), p.to_string()))
10060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10061            ),
10062            _ => local_var_req_builder.query(&[(
10063                "name__niew",
10064                &local_var_str
10065                    .into_iter()
10066                    .map(|p| p.to_string())
10067                    .collect::<Vec<String>>()
10068                    .join(",")
10069                    .to_string(),
10070            )]),
10071        };
10072    }
10073    if let Some(ref local_var_str) = name__nisw {
10074        local_var_req_builder = match "multi" {
10075            "multi" => local_var_req_builder.query(
10076                &local_var_str
10077                    .into_iter()
10078                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
10079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10080            ),
10081            _ => local_var_req_builder.query(&[(
10082                "name__nisw",
10083                &local_var_str
10084                    .into_iter()
10085                    .map(|p| p.to_string())
10086                    .collect::<Vec<String>>()
10087                    .join(",")
10088                    .to_string(),
10089            )]),
10090        };
10091    }
10092    if let Some(ref local_var_str) = name__regex {
10093        local_var_req_builder = match "multi" {
10094            "multi" => local_var_req_builder.query(
10095                &local_var_str
10096                    .into_iter()
10097                    .map(|p| ("name__regex".to_owned(), p.to_string()))
10098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10099            ),
10100            _ => local_var_req_builder.query(&[(
10101                "name__regex",
10102                &local_var_str
10103                    .into_iter()
10104                    .map(|p| p.to_string())
10105                    .collect::<Vec<String>>()
10106                    .join(",")
10107                    .to_string(),
10108            )]),
10109        };
10110    }
10111    if let Some(ref local_var_str) = offset {
10112        local_var_req_builder =
10113            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10114    }
10115    if let Some(ref local_var_str) = ordering {
10116        local_var_req_builder =
10117            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
10118    }
10119    if let Some(ref local_var_str) = owner {
10120        local_var_req_builder = match "multi" {
10121            "multi" => local_var_req_builder.query(
10122                &local_var_str
10123                    .into_iter()
10124                    .map(|p| ("owner".to_owned(), p.to_string()))
10125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10126            ),
10127            _ => local_var_req_builder.query(&[(
10128                "owner",
10129                &local_var_str
10130                    .into_iter()
10131                    .map(|p| p.to_string())
10132                    .collect::<Vec<String>>()
10133                    .join(",")
10134                    .to_string(),
10135            )]),
10136        };
10137    }
10138    if let Some(ref local_var_str) = owner__n {
10139        local_var_req_builder = match "multi" {
10140            "multi" => local_var_req_builder.query(
10141                &local_var_str
10142                    .into_iter()
10143                    .map(|p| ("owner__n".to_owned(), p.to_string()))
10144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10145            ),
10146            _ => local_var_req_builder.query(&[(
10147                "owner__n",
10148                &local_var_str
10149                    .into_iter()
10150                    .map(|p| p.to_string())
10151                    .collect::<Vec<String>>()
10152                    .join(",")
10153                    .to_string(),
10154            )]),
10155        };
10156    }
10157    if let Some(ref local_var_str) = owner_group {
10158        local_var_req_builder = match "multi" {
10159            "multi" => local_var_req_builder.query(
10160                &local_var_str
10161                    .into_iter()
10162                    .map(|p| ("owner_group".to_owned(), p.to_string()))
10163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10164            ),
10165            _ => local_var_req_builder.query(&[(
10166                "owner_group",
10167                &local_var_str
10168                    .into_iter()
10169                    .map(|p| p.to_string())
10170                    .collect::<Vec<String>>()
10171                    .join(",")
10172                    .to_string(),
10173            )]),
10174        };
10175    }
10176    if let Some(ref local_var_str) = owner_group__n {
10177        local_var_req_builder = match "multi" {
10178            "multi" => local_var_req_builder.query(
10179                &local_var_str
10180                    .into_iter()
10181                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
10182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10183            ),
10184            _ => local_var_req_builder.query(&[(
10185                "owner_group__n",
10186                &local_var_str
10187                    .into_iter()
10188                    .map(|p| p.to_string())
10189                    .collect::<Vec<String>>()
10190                    .join(",")
10191                    .to_string(),
10192            )]),
10193        };
10194    }
10195    if let Some(ref local_var_str) = owner_group_id {
10196        local_var_req_builder = match "multi" {
10197            "multi" => local_var_req_builder.query(
10198                &local_var_str
10199                    .into_iter()
10200                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
10201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10202            ),
10203            _ => local_var_req_builder.query(&[(
10204                "owner_group_id",
10205                &local_var_str
10206                    .into_iter()
10207                    .map(|p| p.to_string())
10208                    .collect::<Vec<String>>()
10209                    .join(",")
10210                    .to_string(),
10211            )]),
10212        };
10213    }
10214    if let Some(ref local_var_str) = owner_group_id__n {
10215        local_var_req_builder = match "multi" {
10216            "multi" => local_var_req_builder.query(
10217                &local_var_str
10218                    .into_iter()
10219                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
10220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10221            ),
10222            _ => local_var_req_builder.query(&[(
10223                "owner_group_id__n",
10224                &local_var_str
10225                    .into_iter()
10226                    .map(|p| p.to_string())
10227                    .collect::<Vec<String>>()
10228                    .join(",")
10229                    .to_string(),
10230            )]),
10231        };
10232    }
10233    if let Some(ref local_var_str) = owner_id {
10234        local_var_req_builder = match "multi" {
10235            "multi" => local_var_req_builder.query(
10236                &local_var_str
10237                    .into_iter()
10238                    .map(|p| ("owner_id".to_owned(), p.to_string()))
10239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10240            ),
10241            _ => local_var_req_builder.query(&[(
10242                "owner_id",
10243                &local_var_str
10244                    .into_iter()
10245                    .map(|p| p.to_string())
10246                    .collect::<Vec<String>>()
10247                    .join(",")
10248                    .to_string(),
10249            )]),
10250        };
10251    }
10252    if let Some(ref local_var_str) = owner_id__n {
10253        local_var_req_builder = match "multi" {
10254            "multi" => local_var_req_builder.query(
10255                &local_var_str
10256                    .into_iter()
10257                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
10258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10259            ),
10260            _ => local_var_req_builder.query(&[(
10261                "owner_id__n",
10262                &local_var_str
10263                    .into_iter()
10264                    .map(|p| p.to_string())
10265                    .collect::<Vec<String>>()
10266                    .join(",")
10267                    .to_string(),
10268            )]),
10269        };
10270    }
10271    if let Some(ref local_var_str) = parent {
10272        local_var_req_builder = match "multi" {
10273            "multi" => local_var_req_builder.query(
10274                &local_var_str
10275                    .into_iter()
10276                    .map(|p| ("parent".to_owned(), p.to_string()))
10277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10278            ),
10279            _ => local_var_req_builder.query(&[(
10280                "parent",
10281                &local_var_str
10282                    .into_iter()
10283                    .map(|p| p.to_string())
10284                    .collect::<Vec<String>>()
10285                    .join(",")
10286                    .to_string(),
10287            )]),
10288        };
10289    }
10290    if let Some(ref local_var_str) = parent__n {
10291        local_var_req_builder = match "multi" {
10292            "multi" => local_var_req_builder.query(
10293                &local_var_str
10294                    .into_iter()
10295                    .map(|p| ("parent__n".to_owned(), p.to_string()))
10296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10297            ),
10298            _ => local_var_req_builder.query(&[(
10299                "parent__n",
10300                &local_var_str
10301                    .into_iter()
10302                    .map(|p| p.to_string())
10303                    .collect::<Vec<String>>()
10304                    .join(",")
10305                    .to_string(),
10306            )]),
10307        };
10308    }
10309    if let Some(ref local_var_str) = parent_id {
10310        local_var_req_builder = match "multi" {
10311            "multi" => local_var_req_builder.query(
10312                &local_var_str
10313                    .into_iter()
10314                    .map(|p| ("parent_id".to_owned(), p.to_string()))
10315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10316            ),
10317            _ => local_var_req_builder.query(&[(
10318                "parent_id",
10319                &local_var_str
10320                    .into_iter()
10321                    .map(|p| p.to_string())
10322                    .collect::<Vec<String>>()
10323                    .join(",")
10324                    .to_string(),
10325            )]),
10326        };
10327    }
10328    if let Some(ref local_var_str) = parent_id__n {
10329        local_var_req_builder = match "multi" {
10330            "multi" => local_var_req_builder.query(
10331                &local_var_str
10332                    .into_iter()
10333                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
10334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10335            ),
10336            _ => local_var_req_builder.query(&[(
10337                "parent_id__n",
10338                &local_var_str
10339                    .into_iter()
10340                    .map(|p| p.to_string())
10341                    .collect::<Vec<String>>()
10342                    .join(",")
10343                    .to_string(),
10344            )]),
10345        };
10346    }
10347    if let Some(ref local_var_str) = q {
10348        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
10349    }
10350    if let Some(ref local_var_str) = slug {
10351        local_var_req_builder = match "multi" {
10352            "multi" => local_var_req_builder.query(
10353                &local_var_str
10354                    .into_iter()
10355                    .map(|p| ("slug".to_owned(), p.to_string()))
10356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10357            ),
10358            _ => local_var_req_builder.query(&[(
10359                "slug",
10360                &local_var_str
10361                    .into_iter()
10362                    .map(|p| p.to_string())
10363                    .collect::<Vec<String>>()
10364                    .join(",")
10365                    .to_string(),
10366            )]),
10367        };
10368    }
10369    if let Some(ref local_var_str) = slug__empty {
10370        local_var_req_builder =
10371            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
10372    }
10373    if let Some(ref local_var_str) = slug__ic {
10374        local_var_req_builder = match "multi" {
10375            "multi" => local_var_req_builder.query(
10376                &local_var_str
10377                    .into_iter()
10378                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
10379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10380            ),
10381            _ => local_var_req_builder.query(&[(
10382                "slug__ic",
10383                &local_var_str
10384                    .into_iter()
10385                    .map(|p| p.to_string())
10386                    .collect::<Vec<String>>()
10387                    .join(",")
10388                    .to_string(),
10389            )]),
10390        };
10391    }
10392    if let Some(ref local_var_str) = slug__ie {
10393        local_var_req_builder = match "multi" {
10394            "multi" => local_var_req_builder.query(
10395                &local_var_str
10396                    .into_iter()
10397                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
10398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10399            ),
10400            _ => local_var_req_builder.query(&[(
10401                "slug__ie",
10402                &local_var_str
10403                    .into_iter()
10404                    .map(|p| p.to_string())
10405                    .collect::<Vec<String>>()
10406                    .join(",")
10407                    .to_string(),
10408            )]),
10409        };
10410    }
10411    if let Some(ref local_var_str) = slug__iew {
10412        local_var_req_builder = match "multi" {
10413            "multi" => local_var_req_builder.query(
10414                &local_var_str
10415                    .into_iter()
10416                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
10417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10418            ),
10419            _ => local_var_req_builder.query(&[(
10420                "slug__iew",
10421                &local_var_str
10422                    .into_iter()
10423                    .map(|p| p.to_string())
10424                    .collect::<Vec<String>>()
10425                    .join(",")
10426                    .to_string(),
10427            )]),
10428        };
10429    }
10430    if let Some(ref local_var_str) = slug__iregex {
10431        local_var_req_builder = match "multi" {
10432            "multi" => local_var_req_builder.query(
10433                &local_var_str
10434                    .into_iter()
10435                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
10436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10437            ),
10438            _ => local_var_req_builder.query(&[(
10439                "slug__iregex",
10440                &local_var_str
10441                    .into_iter()
10442                    .map(|p| p.to_string())
10443                    .collect::<Vec<String>>()
10444                    .join(",")
10445                    .to_string(),
10446            )]),
10447        };
10448    }
10449    if let Some(ref local_var_str) = slug__isw {
10450        local_var_req_builder = match "multi" {
10451            "multi" => local_var_req_builder.query(
10452                &local_var_str
10453                    .into_iter()
10454                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
10455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10456            ),
10457            _ => local_var_req_builder.query(&[(
10458                "slug__isw",
10459                &local_var_str
10460                    .into_iter()
10461                    .map(|p| p.to_string())
10462                    .collect::<Vec<String>>()
10463                    .join(",")
10464                    .to_string(),
10465            )]),
10466        };
10467    }
10468    if let Some(ref local_var_str) = slug__n {
10469        local_var_req_builder = match "multi" {
10470            "multi" => local_var_req_builder.query(
10471                &local_var_str
10472                    .into_iter()
10473                    .map(|p| ("slug__n".to_owned(), p.to_string()))
10474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10475            ),
10476            _ => local_var_req_builder.query(&[(
10477                "slug__n",
10478                &local_var_str
10479                    .into_iter()
10480                    .map(|p| p.to_string())
10481                    .collect::<Vec<String>>()
10482                    .join(",")
10483                    .to_string(),
10484            )]),
10485        };
10486    }
10487    if let Some(ref local_var_str) = slug__nic {
10488        local_var_req_builder = match "multi" {
10489            "multi" => local_var_req_builder.query(
10490                &local_var_str
10491                    .into_iter()
10492                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
10493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10494            ),
10495            _ => local_var_req_builder.query(&[(
10496                "slug__nic",
10497                &local_var_str
10498                    .into_iter()
10499                    .map(|p| p.to_string())
10500                    .collect::<Vec<String>>()
10501                    .join(",")
10502                    .to_string(),
10503            )]),
10504        };
10505    }
10506    if let Some(ref local_var_str) = slug__nie {
10507        local_var_req_builder = match "multi" {
10508            "multi" => local_var_req_builder.query(
10509                &local_var_str
10510                    .into_iter()
10511                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
10512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10513            ),
10514            _ => local_var_req_builder.query(&[(
10515                "slug__nie",
10516                &local_var_str
10517                    .into_iter()
10518                    .map(|p| p.to_string())
10519                    .collect::<Vec<String>>()
10520                    .join(",")
10521                    .to_string(),
10522            )]),
10523        };
10524    }
10525    if let Some(ref local_var_str) = slug__niew {
10526        local_var_req_builder = match "multi" {
10527            "multi" => local_var_req_builder.query(
10528                &local_var_str
10529                    .into_iter()
10530                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
10531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10532            ),
10533            _ => local_var_req_builder.query(&[(
10534                "slug__niew",
10535                &local_var_str
10536                    .into_iter()
10537                    .map(|p| p.to_string())
10538                    .collect::<Vec<String>>()
10539                    .join(",")
10540                    .to_string(),
10541            )]),
10542        };
10543    }
10544    if let Some(ref local_var_str) = slug__nisw {
10545        local_var_req_builder = match "multi" {
10546            "multi" => local_var_req_builder.query(
10547                &local_var_str
10548                    .into_iter()
10549                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
10550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10551            ),
10552            _ => local_var_req_builder.query(&[(
10553                "slug__nisw",
10554                &local_var_str
10555                    .into_iter()
10556                    .map(|p| p.to_string())
10557                    .collect::<Vec<String>>()
10558                    .join(",")
10559                    .to_string(),
10560            )]),
10561        };
10562    }
10563    if let Some(ref local_var_str) = slug__regex {
10564        local_var_req_builder = match "multi" {
10565            "multi" => local_var_req_builder.query(
10566                &local_var_str
10567                    .into_iter()
10568                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
10569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10570            ),
10571            _ => local_var_req_builder.query(&[(
10572                "slug__regex",
10573                &local_var_str
10574                    .into_iter()
10575                    .map(|p| p.to_string())
10576                    .collect::<Vec<String>>()
10577                    .join(",")
10578                    .to_string(),
10579            )]),
10580        };
10581    }
10582    if let Some(ref local_var_str) = tag {
10583        local_var_req_builder = match "multi" {
10584            "multi" => local_var_req_builder.query(
10585                &local_var_str
10586                    .into_iter()
10587                    .map(|p| ("tag".to_owned(), p.to_string()))
10588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10589            ),
10590            _ => local_var_req_builder.query(&[(
10591                "tag",
10592                &local_var_str
10593                    .into_iter()
10594                    .map(|p| p.to_string())
10595                    .collect::<Vec<String>>()
10596                    .join(",")
10597                    .to_string(),
10598            )]),
10599        };
10600    }
10601    if let Some(ref local_var_str) = tag__n {
10602        local_var_req_builder = match "multi" {
10603            "multi" => local_var_req_builder.query(
10604                &local_var_str
10605                    .into_iter()
10606                    .map(|p| ("tag__n".to_owned(), p.to_string()))
10607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10608            ),
10609            _ => local_var_req_builder.query(&[(
10610                "tag__n",
10611                &local_var_str
10612                    .into_iter()
10613                    .map(|p| p.to_string())
10614                    .collect::<Vec<String>>()
10615                    .join(",")
10616                    .to_string(),
10617            )]),
10618        };
10619    }
10620    if let Some(ref local_var_str) = tag_id {
10621        local_var_req_builder = match "multi" {
10622            "multi" => local_var_req_builder.query(
10623                &local_var_str
10624                    .into_iter()
10625                    .map(|p| ("tag_id".to_owned(), p.to_string()))
10626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10627            ),
10628            _ => local_var_req_builder.query(&[(
10629                "tag_id",
10630                &local_var_str
10631                    .into_iter()
10632                    .map(|p| p.to_string())
10633                    .collect::<Vec<String>>()
10634                    .join(",")
10635                    .to_string(),
10636            )]),
10637        };
10638    }
10639    if let Some(ref local_var_str) = tag_id__n {
10640        local_var_req_builder = match "multi" {
10641            "multi" => local_var_req_builder.query(
10642                &local_var_str
10643                    .into_iter()
10644                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
10645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10646            ),
10647            _ => local_var_req_builder.query(&[(
10648                "tag_id__n",
10649                &local_var_str
10650                    .into_iter()
10651                    .map(|p| p.to_string())
10652                    .collect::<Vec<String>>()
10653                    .join(",")
10654                    .to_string(),
10655            )]),
10656        };
10657    }
10658    if let Some(ref local_var_str) = updated_by_request {
10659        local_var_req_builder =
10660            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
10661    }
10662    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10663        local_var_req_builder =
10664            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10665    }
10666    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10667        let local_var_key = local_var_apikey.key.clone();
10668        let local_var_value = match local_var_apikey.prefix {
10669            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10670            None => local_var_key,
10671        };
10672        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10673    };
10674
10675    let local_var_req = local_var_req_builder.build()?;
10676    let local_var_resp = local_var_client.execute(local_var_req).await?;
10677
10678    let local_var_status = local_var_resp.status();
10679    let local_var_content = local_var_resp.text().await?;
10680
10681    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10682        serde_json::from_str(&local_var_content).map_err(Error::from)
10683    } else {
10684        let local_var_entity: Option<TenancyTenantGroupsListError> =
10685            serde_json::from_str(&local_var_content).ok();
10686        let local_var_error = ResponseContent {
10687            status: local_var_status,
10688            content: local_var_content,
10689            entity: local_var_entity,
10690        };
10691        Err(Error::ResponseError(local_var_error))
10692    }
10693}
10694
10695/// Patch a tenant group object.
10696pub async fn tenancy_tenant_groups_partial_update(
10697    configuration: &configuration::Configuration,
10698    id: i32,
10699    patched_writable_tenant_group_request: Option<crate::models::PatchedWritableTenantGroupRequest>,
10700) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsPartialUpdateError>> {
10701    let local_var_configuration = configuration;
10702
10703    let local_var_client = &local_var_configuration.client;
10704
10705    let local_var_uri_str = format!(
10706        "{}/api/tenancy/tenant-groups/{id}/",
10707        local_var_configuration.base_path,
10708        id = id
10709    );
10710    let mut local_var_req_builder =
10711        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10712
10713    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10714        local_var_req_builder =
10715            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10716    }
10717    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10718        let local_var_key = local_var_apikey.key.clone();
10719        let local_var_value = match local_var_apikey.prefix {
10720            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10721            None => local_var_key,
10722        };
10723        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10724    };
10725    local_var_req_builder = local_var_req_builder.json(&patched_writable_tenant_group_request);
10726
10727    let local_var_req = local_var_req_builder.build()?;
10728    let local_var_resp = local_var_client.execute(local_var_req).await?;
10729
10730    let local_var_status = local_var_resp.status();
10731    let local_var_content = local_var_resp.text().await?;
10732
10733    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10734        serde_json::from_str(&local_var_content).map_err(Error::from)
10735    } else {
10736        let local_var_entity: Option<TenancyTenantGroupsPartialUpdateError> =
10737            serde_json::from_str(&local_var_content).ok();
10738        let local_var_error = ResponseContent {
10739            status: local_var_status,
10740            content: local_var_content,
10741            entity: local_var_entity,
10742        };
10743        Err(Error::ResponseError(local_var_error))
10744    }
10745}
10746
10747/// Get a tenant group object.
10748pub async fn tenancy_tenant_groups_retrieve(
10749    configuration: &configuration::Configuration,
10750    id: i32,
10751) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsRetrieveError>> {
10752    let local_var_configuration = configuration;
10753
10754    let local_var_client = &local_var_configuration.client;
10755
10756    let local_var_uri_str = format!(
10757        "{}/api/tenancy/tenant-groups/{id}/",
10758        local_var_configuration.base_path,
10759        id = id
10760    );
10761    let mut local_var_req_builder =
10762        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10763
10764    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10765        local_var_req_builder =
10766            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10767    }
10768    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10769        let local_var_key = local_var_apikey.key.clone();
10770        let local_var_value = match local_var_apikey.prefix {
10771            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10772            None => local_var_key,
10773        };
10774        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10775    };
10776
10777    let local_var_req = local_var_req_builder.build()?;
10778    let local_var_resp = local_var_client.execute(local_var_req).await?;
10779
10780    let local_var_status = local_var_resp.status();
10781    let local_var_content = local_var_resp.text().await?;
10782
10783    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10784        serde_json::from_str(&local_var_content).map_err(Error::from)
10785    } else {
10786        let local_var_entity: Option<TenancyTenantGroupsRetrieveError> =
10787            serde_json::from_str(&local_var_content).ok();
10788        let local_var_error = ResponseContent {
10789            status: local_var_status,
10790            content: local_var_content,
10791            entity: local_var_entity,
10792        };
10793        Err(Error::ResponseError(local_var_error))
10794    }
10795}
10796
10797/// Put a tenant group object.
10798pub async fn tenancy_tenant_groups_update(
10799    configuration: &configuration::Configuration,
10800    id: i32,
10801    writable_tenant_group_request: crate::models::WritableTenantGroupRequest,
10802) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsUpdateError>> {
10803    let local_var_configuration = configuration;
10804
10805    let local_var_client = &local_var_configuration.client;
10806
10807    let local_var_uri_str = format!(
10808        "{}/api/tenancy/tenant-groups/{id}/",
10809        local_var_configuration.base_path,
10810        id = id
10811    );
10812    let mut local_var_req_builder =
10813        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10814
10815    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10816        local_var_req_builder =
10817            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10818    }
10819    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10820        let local_var_key = local_var_apikey.key.clone();
10821        let local_var_value = match local_var_apikey.prefix {
10822            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10823            None => local_var_key,
10824        };
10825        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10826    };
10827    local_var_req_builder = local_var_req_builder.json(&writable_tenant_group_request);
10828
10829    let local_var_req = local_var_req_builder.build()?;
10830    let local_var_resp = local_var_client.execute(local_var_req).await?;
10831
10832    let local_var_status = local_var_resp.status();
10833    let local_var_content = local_var_resp.text().await?;
10834
10835    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10836        serde_json::from_str(&local_var_content).map_err(Error::from)
10837    } else {
10838        let local_var_entity: Option<TenancyTenantGroupsUpdateError> =
10839            serde_json::from_str(&local_var_content).ok();
10840        let local_var_error = ResponseContent {
10841            status: local_var_status,
10842            content: local_var_content,
10843            entity: local_var_entity,
10844        };
10845        Err(Error::ResponseError(local_var_error))
10846    }
10847}
10848
10849/// Delete a list of tenant objects.
10850pub async fn tenancy_tenants_bulk_destroy(
10851    configuration: &configuration::Configuration,
10852    tenant_request: Vec<crate::models::TenantRequest>,
10853) -> Result<(), Error<TenancyTenantsBulkDestroyError>> {
10854    let local_var_configuration = configuration;
10855
10856    let local_var_client = &local_var_configuration.client;
10857
10858    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10859    let mut local_var_req_builder =
10860        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10861
10862    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10863        local_var_req_builder =
10864            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10865    }
10866    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10867        let local_var_key = local_var_apikey.key.clone();
10868        let local_var_value = match local_var_apikey.prefix {
10869            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10870            None => local_var_key,
10871        };
10872        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10873    };
10874    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10875
10876    let local_var_req = local_var_req_builder.build()?;
10877    let local_var_resp = local_var_client.execute(local_var_req).await?;
10878
10879    let local_var_status = local_var_resp.status();
10880    let local_var_content = local_var_resp.text().await?;
10881
10882    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10883        Ok(())
10884    } else {
10885        let local_var_entity: Option<TenancyTenantsBulkDestroyError> =
10886            serde_json::from_str(&local_var_content).ok();
10887        let local_var_error = ResponseContent {
10888            status: local_var_status,
10889            content: local_var_content,
10890            entity: local_var_entity,
10891        };
10892        Err(Error::ResponseError(local_var_error))
10893    }
10894}
10895
10896/// Patch a list of tenant objects.
10897pub async fn tenancy_tenants_bulk_partial_update(
10898    configuration: &configuration::Configuration,
10899    tenant_request: Vec<crate::models::TenantRequest>,
10900) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkPartialUpdateError>> {
10901    let local_var_configuration = configuration;
10902
10903    let local_var_client = &local_var_configuration.client;
10904
10905    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10906    let mut local_var_req_builder =
10907        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10908
10909    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10910        local_var_req_builder =
10911            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10912    }
10913    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10914        let local_var_key = local_var_apikey.key.clone();
10915        let local_var_value = match local_var_apikey.prefix {
10916            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10917            None => local_var_key,
10918        };
10919        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10920    };
10921    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10922
10923    let local_var_req = local_var_req_builder.build()?;
10924    let local_var_resp = local_var_client.execute(local_var_req).await?;
10925
10926    let local_var_status = local_var_resp.status();
10927    let local_var_content = local_var_resp.text().await?;
10928
10929    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10930        serde_json::from_str(&local_var_content).map_err(Error::from)
10931    } else {
10932        let local_var_entity: Option<TenancyTenantsBulkPartialUpdateError> =
10933            serde_json::from_str(&local_var_content).ok();
10934        let local_var_error = ResponseContent {
10935            status: local_var_status,
10936            content: local_var_content,
10937            entity: local_var_entity,
10938        };
10939        Err(Error::ResponseError(local_var_error))
10940    }
10941}
10942
10943/// Put a list of tenant objects.
10944pub async fn tenancy_tenants_bulk_update(
10945    configuration: &configuration::Configuration,
10946    tenant_request: Vec<crate::models::TenantRequest>,
10947) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkUpdateError>> {
10948    let local_var_configuration = configuration;
10949
10950    let local_var_client = &local_var_configuration.client;
10951
10952    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10953    let mut local_var_req_builder =
10954        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10955
10956    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10957        local_var_req_builder =
10958            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10959    }
10960    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10961        let local_var_key = local_var_apikey.key.clone();
10962        let local_var_value = match local_var_apikey.prefix {
10963            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10964            None => local_var_key,
10965        };
10966        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10967    };
10968    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10969
10970    let local_var_req = local_var_req_builder.build()?;
10971    let local_var_resp = local_var_client.execute(local_var_req).await?;
10972
10973    let local_var_status = local_var_resp.status();
10974    let local_var_content = local_var_resp.text().await?;
10975
10976    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10977        serde_json::from_str(&local_var_content).map_err(Error::from)
10978    } else {
10979        let local_var_entity: Option<TenancyTenantsBulkUpdateError> =
10980            serde_json::from_str(&local_var_content).ok();
10981        let local_var_error = ResponseContent {
10982            status: local_var_status,
10983            content: local_var_content,
10984            entity: local_var_entity,
10985        };
10986        Err(Error::ResponseError(local_var_error))
10987    }
10988}
10989
10990/// Post a list of tenant objects.
10991pub async fn tenancy_tenants_create(
10992    configuration: &configuration::Configuration,
10993    tenancy_tenants_create_request: crate::models::TenancyTenantsCreateRequest,
10994) -> Result<crate::models::Tenant, Error<TenancyTenantsCreateError>> {
10995    let local_var_configuration = configuration;
10996
10997    let local_var_client = &local_var_configuration.client;
10998
10999    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
11000    let mut local_var_req_builder =
11001        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11002
11003    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11004        local_var_req_builder =
11005            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11006    }
11007    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11008        let local_var_key = local_var_apikey.key.clone();
11009        let local_var_value = match local_var_apikey.prefix {
11010            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11011            None => local_var_key,
11012        };
11013        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11014    };
11015    local_var_req_builder = local_var_req_builder.json(&tenancy_tenants_create_request);
11016
11017    let local_var_req = local_var_req_builder.build()?;
11018    let local_var_resp = local_var_client.execute(local_var_req).await?;
11019
11020    let local_var_status = local_var_resp.status();
11021    let local_var_content = local_var_resp.text().await?;
11022
11023    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11024        serde_json::from_str(&local_var_content).map_err(Error::from)
11025    } else {
11026        let local_var_entity: Option<TenancyTenantsCreateError> =
11027            serde_json::from_str(&local_var_content).ok();
11028        let local_var_error = ResponseContent {
11029            status: local_var_status,
11030            content: local_var_content,
11031            entity: local_var_entity,
11032        };
11033        Err(Error::ResponseError(local_var_error))
11034    }
11035}
11036
11037/// Delete a tenant object.
11038pub async fn tenancy_tenants_destroy(
11039    configuration: &configuration::Configuration,
11040    id: i32,
11041) -> Result<(), Error<TenancyTenantsDestroyError>> {
11042    let local_var_configuration = configuration;
11043
11044    let local_var_client = &local_var_configuration.client;
11045
11046    let local_var_uri_str = format!(
11047        "{}/api/tenancy/tenants/{id}/",
11048        local_var_configuration.base_path,
11049        id = id
11050    );
11051    let mut local_var_req_builder =
11052        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11053
11054    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11055        local_var_req_builder =
11056            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11057    }
11058    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11059        let local_var_key = local_var_apikey.key.clone();
11060        let local_var_value = match local_var_apikey.prefix {
11061            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11062            None => local_var_key,
11063        };
11064        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11065    };
11066
11067    let local_var_req = local_var_req_builder.build()?;
11068    let local_var_resp = local_var_client.execute(local_var_req).await?;
11069
11070    let local_var_status = local_var_resp.status();
11071    let local_var_content = local_var_resp.text().await?;
11072
11073    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11074        Ok(())
11075    } else {
11076        let local_var_entity: Option<TenancyTenantsDestroyError> =
11077            serde_json::from_str(&local_var_content).ok();
11078        let local_var_error = ResponseContent {
11079            status: local_var_status,
11080            content: local_var_content,
11081            entity: local_var_entity,
11082        };
11083        Err(Error::ResponseError(local_var_error))
11084    }
11085}
11086
11087/// Get a list of tenant objects.
11088pub async fn tenancy_tenants_list(
11089    configuration: &configuration::Configuration,
11090    contact: Option<Vec<i32>>,
11091    contact__n: Option<Vec<i32>>,
11092    contact_group: Option<Vec<String>>,
11093    contact_group__n: Option<Vec<String>>,
11094    contact_role: Option<Vec<i32>>,
11095    contact_role__n: Option<Vec<i32>>,
11096    created: Option<Vec<String>>,
11097    created__empty: Option<Vec<String>>,
11098    created__gt: Option<Vec<String>>,
11099    created__gte: Option<Vec<String>>,
11100    created__lt: Option<Vec<String>>,
11101    created__lte: Option<Vec<String>>,
11102    created__n: Option<Vec<String>>,
11103    created_by_request: Option<&str>,
11104    description: Option<Vec<String>>,
11105    description__empty: Option<bool>,
11106    description__ic: Option<Vec<String>>,
11107    description__ie: Option<Vec<String>>,
11108    description__iew: Option<Vec<String>>,
11109    description__iregex: Option<Vec<String>>,
11110    description__isw: Option<Vec<String>>,
11111    description__n: Option<Vec<String>>,
11112    description__nic: Option<Vec<String>>,
11113    description__nie: Option<Vec<String>>,
11114    description__niew: Option<Vec<String>>,
11115    description__nisw: Option<Vec<String>>,
11116    description__regex: Option<Vec<String>>,
11117    group: Option<Vec<String>>,
11118    group__n: Option<Vec<String>>,
11119    group_id: Option<Vec<String>>,
11120    group_id__n: Option<Vec<String>>,
11121    id: Option<Vec<i32>>,
11122    id__empty: Option<bool>,
11123    id__gt: Option<Vec<i32>>,
11124    id__gte: Option<Vec<i32>>,
11125    id__lt: Option<Vec<i32>>,
11126    id__lte: Option<Vec<i32>>,
11127    id__n: Option<Vec<i32>>,
11128    last_updated: Option<Vec<String>>,
11129    last_updated__empty: Option<Vec<String>>,
11130    last_updated__gt: Option<Vec<String>>,
11131    last_updated__gte: Option<Vec<String>>,
11132    last_updated__lt: Option<Vec<String>>,
11133    last_updated__lte: Option<Vec<String>>,
11134    last_updated__n: Option<Vec<String>>,
11135    limit: Option<i32>,
11136    modified_by_request: Option<&str>,
11137    name: Option<Vec<String>>,
11138    name__empty: Option<bool>,
11139    name__ic: Option<Vec<String>>,
11140    name__ie: Option<Vec<String>>,
11141    name__iew: Option<Vec<String>>,
11142    name__iregex: Option<Vec<String>>,
11143    name__isw: Option<Vec<String>>,
11144    name__n: Option<Vec<String>>,
11145    name__nic: Option<Vec<String>>,
11146    name__nie: Option<Vec<String>>,
11147    name__niew: Option<Vec<String>>,
11148    name__nisw: Option<Vec<String>>,
11149    name__regex: Option<Vec<String>>,
11150    offset: Option<i32>,
11151    ordering: Option<&str>,
11152    owner: Option<Vec<String>>,
11153    owner__n: Option<Vec<String>>,
11154    owner_group: Option<Vec<String>>,
11155    owner_group__n: Option<Vec<String>>,
11156    owner_group_id: Option<Vec<i32>>,
11157    owner_group_id__n: Option<Vec<i32>>,
11158    owner_id: Option<Vec<i32>>,
11159    owner_id__n: Option<Vec<i32>>,
11160    q: Option<&str>,
11161    slug: Option<Vec<String>>,
11162    slug__empty: Option<bool>,
11163    slug__ic: Option<Vec<String>>,
11164    slug__ie: Option<Vec<String>>,
11165    slug__iew: Option<Vec<String>>,
11166    slug__iregex: Option<Vec<String>>,
11167    slug__isw: Option<Vec<String>>,
11168    slug__n: Option<Vec<String>>,
11169    slug__nic: Option<Vec<String>>,
11170    slug__nie: Option<Vec<String>>,
11171    slug__niew: Option<Vec<String>>,
11172    slug__nisw: Option<Vec<String>>,
11173    slug__regex: Option<Vec<String>>,
11174    tag: Option<Vec<String>>,
11175    tag__n: Option<Vec<String>>,
11176    tag_id: Option<Vec<i32>>,
11177    tag_id__n: Option<Vec<i32>>,
11178    updated_by_request: Option<&str>,
11179) -> Result<crate::models::PaginatedTenantList, Error<TenancyTenantsListError>> {
11180    let local_var_configuration = configuration;
11181
11182    let local_var_client = &local_var_configuration.client;
11183
11184    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
11185    let mut local_var_req_builder =
11186        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11187
11188    if let Some(ref local_var_str) = contact {
11189        local_var_req_builder = match "multi" {
11190            "multi" => local_var_req_builder.query(
11191                &local_var_str
11192                    .into_iter()
11193                    .map(|p| ("contact".to_owned(), p.to_string()))
11194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11195            ),
11196            _ => local_var_req_builder.query(&[(
11197                "contact",
11198                &local_var_str
11199                    .into_iter()
11200                    .map(|p| p.to_string())
11201                    .collect::<Vec<String>>()
11202                    .join(",")
11203                    .to_string(),
11204            )]),
11205        };
11206    }
11207    if let Some(ref local_var_str) = contact__n {
11208        local_var_req_builder = match "multi" {
11209            "multi" => local_var_req_builder.query(
11210                &local_var_str
11211                    .into_iter()
11212                    .map(|p| ("contact__n".to_owned(), p.to_string()))
11213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11214            ),
11215            _ => local_var_req_builder.query(&[(
11216                "contact__n",
11217                &local_var_str
11218                    .into_iter()
11219                    .map(|p| p.to_string())
11220                    .collect::<Vec<String>>()
11221                    .join(",")
11222                    .to_string(),
11223            )]),
11224        };
11225    }
11226    if let Some(ref local_var_str) = contact_group {
11227        local_var_req_builder = match "multi" {
11228            "multi" => local_var_req_builder.query(
11229                &local_var_str
11230                    .into_iter()
11231                    .map(|p| ("contact_group".to_owned(), p.to_string()))
11232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11233            ),
11234            _ => local_var_req_builder.query(&[(
11235                "contact_group",
11236                &local_var_str
11237                    .into_iter()
11238                    .map(|p| p.to_string())
11239                    .collect::<Vec<String>>()
11240                    .join(",")
11241                    .to_string(),
11242            )]),
11243        };
11244    }
11245    if let Some(ref local_var_str) = contact_group__n {
11246        local_var_req_builder = match "multi" {
11247            "multi" => local_var_req_builder.query(
11248                &local_var_str
11249                    .into_iter()
11250                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
11251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11252            ),
11253            _ => local_var_req_builder.query(&[(
11254                "contact_group__n",
11255                &local_var_str
11256                    .into_iter()
11257                    .map(|p| p.to_string())
11258                    .collect::<Vec<String>>()
11259                    .join(",")
11260                    .to_string(),
11261            )]),
11262        };
11263    }
11264    if let Some(ref local_var_str) = contact_role {
11265        local_var_req_builder = match "multi" {
11266            "multi" => local_var_req_builder.query(
11267                &local_var_str
11268                    .into_iter()
11269                    .map(|p| ("contact_role".to_owned(), p.to_string()))
11270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11271            ),
11272            _ => local_var_req_builder.query(&[(
11273                "contact_role",
11274                &local_var_str
11275                    .into_iter()
11276                    .map(|p| p.to_string())
11277                    .collect::<Vec<String>>()
11278                    .join(",")
11279                    .to_string(),
11280            )]),
11281        };
11282    }
11283    if let Some(ref local_var_str) = contact_role__n {
11284        local_var_req_builder = match "multi" {
11285            "multi" => local_var_req_builder.query(
11286                &local_var_str
11287                    .into_iter()
11288                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
11289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11290            ),
11291            _ => local_var_req_builder.query(&[(
11292                "contact_role__n",
11293                &local_var_str
11294                    .into_iter()
11295                    .map(|p| p.to_string())
11296                    .collect::<Vec<String>>()
11297                    .join(",")
11298                    .to_string(),
11299            )]),
11300        };
11301    }
11302    if let Some(ref local_var_str) = created {
11303        local_var_req_builder = match "multi" {
11304            "multi" => local_var_req_builder.query(
11305                &local_var_str
11306                    .into_iter()
11307                    .map(|p| ("created".to_owned(), p.to_string()))
11308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11309            ),
11310            _ => local_var_req_builder.query(&[(
11311                "created",
11312                &local_var_str
11313                    .into_iter()
11314                    .map(|p| p.to_string())
11315                    .collect::<Vec<String>>()
11316                    .join(",")
11317                    .to_string(),
11318            )]),
11319        };
11320    }
11321    if let Some(ref local_var_str) = created__empty {
11322        local_var_req_builder = match "multi" {
11323            "multi" => local_var_req_builder.query(
11324                &local_var_str
11325                    .into_iter()
11326                    .map(|p| ("created__empty".to_owned(), p.to_string()))
11327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11328            ),
11329            _ => local_var_req_builder.query(&[(
11330                "created__empty",
11331                &local_var_str
11332                    .into_iter()
11333                    .map(|p| p.to_string())
11334                    .collect::<Vec<String>>()
11335                    .join(",")
11336                    .to_string(),
11337            )]),
11338        };
11339    }
11340    if let Some(ref local_var_str) = created__gt {
11341        local_var_req_builder = match "multi" {
11342            "multi" => local_var_req_builder.query(
11343                &local_var_str
11344                    .into_iter()
11345                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11347            ),
11348            _ => local_var_req_builder.query(&[(
11349                "created__gt",
11350                &local_var_str
11351                    .into_iter()
11352                    .map(|p| p.to_string())
11353                    .collect::<Vec<String>>()
11354                    .join(",")
11355                    .to_string(),
11356            )]),
11357        };
11358    }
11359    if let Some(ref local_var_str) = created__gte {
11360        local_var_req_builder = match "multi" {
11361            "multi" => local_var_req_builder.query(
11362                &local_var_str
11363                    .into_iter()
11364                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11366            ),
11367            _ => local_var_req_builder.query(&[(
11368                "created__gte",
11369                &local_var_str
11370                    .into_iter()
11371                    .map(|p| p.to_string())
11372                    .collect::<Vec<String>>()
11373                    .join(",")
11374                    .to_string(),
11375            )]),
11376        };
11377    }
11378    if let Some(ref local_var_str) = created__lt {
11379        local_var_req_builder = match "multi" {
11380            "multi" => local_var_req_builder.query(
11381                &local_var_str
11382                    .into_iter()
11383                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11385            ),
11386            _ => local_var_req_builder.query(&[(
11387                "created__lt",
11388                &local_var_str
11389                    .into_iter()
11390                    .map(|p| p.to_string())
11391                    .collect::<Vec<String>>()
11392                    .join(",")
11393                    .to_string(),
11394            )]),
11395        };
11396    }
11397    if let Some(ref local_var_str) = created__lte {
11398        local_var_req_builder = match "multi" {
11399            "multi" => local_var_req_builder.query(
11400                &local_var_str
11401                    .into_iter()
11402                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11404            ),
11405            _ => local_var_req_builder.query(&[(
11406                "created__lte",
11407                &local_var_str
11408                    .into_iter()
11409                    .map(|p| p.to_string())
11410                    .collect::<Vec<String>>()
11411                    .join(",")
11412                    .to_string(),
11413            )]),
11414        };
11415    }
11416    if let Some(ref local_var_str) = created__n {
11417        local_var_req_builder = match "multi" {
11418            "multi" => local_var_req_builder.query(
11419                &local_var_str
11420                    .into_iter()
11421                    .map(|p| ("created__n".to_owned(), p.to_string()))
11422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11423            ),
11424            _ => local_var_req_builder.query(&[(
11425                "created__n",
11426                &local_var_str
11427                    .into_iter()
11428                    .map(|p| p.to_string())
11429                    .collect::<Vec<String>>()
11430                    .join(",")
11431                    .to_string(),
11432            )]),
11433        };
11434    }
11435    if let Some(ref local_var_str) = created_by_request {
11436        local_var_req_builder =
11437            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
11438    }
11439    if let Some(ref local_var_str) = description {
11440        local_var_req_builder = match "multi" {
11441            "multi" => local_var_req_builder.query(
11442                &local_var_str
11443                    .into_iter()
11444                    .map(|p| ("description".to_owned(), p.to_string()))
11445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11446            ),
11447            _ => local_var_req_builder.query(&[(
11448                "description",
11449                &local_var_str
11450                    .into_iter()
11451                    .map(|p| p.to_string())
11452                    .collect::<Vec<String>>()
11453                    .join(",")
11454                    .to_string(),
11455            )]),
11456        };
11457    }
11458    if let Some(ref local_var_str) = description__empty {
11459        local_var_req_builder =
11460            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
11461    }
11462    if let Some(ref local_var_str) = description__ic {
11463        local_var_req_builder = match "multi" {
11464            "multi" => local_var_req_builder.query(
11465                &local_var_str
11466                    .into_iter()
11467                    .map(|p| ("description__ic".to_owned(), p.to_string()))
11468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11469            ),
11470            _ => local_var_req_builder.query(&[(
11471                "description__ic",
11472                &local_var_str
11473                    .into_iter()
11474                    .map(|p| p.to_string())
11475                    .collect::<Vec<String>>()
11476                    .join(",")
11477                    .to_string(),
11478            )]),
11479        };
11480    }
11481    if let Some(ref local_var_str) = description__ie {
11482        local_var_req_builder = match "multi" {
11483            "multi" => local_var_req_builder.query(
11484                &local_var_str
11485                    .into_iter()
11486                    .map(|p| ("description__ie".to_owned(), p.to_string()))
11487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11488            ),
11489            _ => local_var_req_builder.query(&[(
11490                "description__ie",
11491                &local_var_str
11492                    .into_iter()
11493                    .map(|p| p.to_string())
11494                    .collect::<Vec<String>>()
11495                    .join(",")
11496                    .to_string(),
11497            )]),
11498        };
11499    }
11500    if let Some(ref local_var_str) = description__iew {
11501        local_var_req_builder = match "multi" {
11502            "multi" => local_var_req_builder.query(
11503                &local_var_str
11504                    .into_iter()
11505                    .map(|p| ("description__iew".to_owned(), p.to_string()))
11506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11507            ),
11508            _ => local_var_req_builder.query(&[(
11509                "description__iew",
11510                &local_var_str
11511                    .into_iter()
11512                    .map(|p| p.to_string())
11513                    .collect::<Vec<String>>()
11514                    .join(",")
11515                    .to_string(),
11516            )]),
11517        };
11518    }
11519    if let Some(ref local_var_str) = description__iregex {
11520        local_var_req_builder = match "multi" {
11521            "multi" => local_var_req_builder.query(
11522                &local_var_str
11523                    .into_iter()
11524                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
11525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11526            ),
11527            _ => local_var_req_builder.query(&[(
11528                "description__iregex",
11529                &local_var_str
11530                    .into_iter()
11531                    .map(|p| p.to_string())
11532                    .collect::<Vec<String>>()
11533                    .join(",")
11534                    .to_string(),
11535            )]),
11536        };
11537    }
11538    if let Some(ref local_var_str) = description__isw {
11539        local_var_req_builder = match "multi" {
11540            "multi" => local_var_req_builder.query(
11541                &local_var_str
11542                    .into_iter()
11543                    .map(|p| ("description__isw".to_owned(), p.to_string()))
11544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11545            ),
11546            _ => local_var_req_builder.query(&[(
11547                "description__isw",
11548                &local_var_str
11549                    .into_iter()
11550                    .map(|p| p.to_string())
11551                    .collect::<Vec<String>>()
11552                    .join(",")
11553                    .to_string(),
11554            )]),
11555        };
11556    }
11557    if let Some(ref local_var_str) = description__n {
11558        local_var_req_builder = match "multi" {
11559            "multi" => local_var_req_builder.query(
11560                &local_var_str
11561                    .into_iter()
11562                    .map(|p| ("description__n".to_owned(), p.to_string()))
11563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11564            ),
11565            _ => local_var_req_builder.query(&[(
11566                "description__n",
11567                &local_var_str
11568                    .into_iter()
11569                    .map(|p| p.to_string())
11570                    .collect::<Vec<String>>()
11571                    .join(",")
11572                    .to_string(),
11573            )]),
11574        };
11575    }
11576    if let Some(ref local_var_str) = description__nic {
11577        local_var_req_builder = match "multi" {
11578            "multi" => local_var_req_builder.query(
11579                &local_var_str
11580                    .into_iter()
11581                    .map(|p| ("description__nic".to_owned(), p.to_string()))
11582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11583            ),
11584            _ => local_var_req_builder.query(&[(
11585                "description__nic",
11586                &local_var_str
11587                    .into_iter()
11588                    .map(|p| p.to_string())
11589                    .collect::<Vec<String>>()
11590                    .join(",")
11591                    .to_string(),
11592            )]),
11593        };
11594    }
11595    if let Some(ref local_var_str) = description__nie {
11596        local_var_req_builder = match "multi" {
11597            "multi" => local_var_req_builder.query(
11598                &local_var_str
11599                    .into_iter()
11600                    .map(|p| ("description__nie".to_owned(), p.to_string()))
11601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11602            ),
11603            _ => local_var_req_builder.query(&[(
11604                "description__nie",
11605                &local_var_str
11606                    .into_iter()
11607                    .map(|p| p.to_string())
11608                    .collect::<Vec<String>>()
11609                    .join(",")
11610                    .to_string(),
11611            )]),
11612        };
11613    }
11614    if let Some(ref local_var_str) = description__niew {
11615        local_var_req_builder = match "multi" {
11616            "multi" => local_var_req_builder.query(
11617                &local_var_str
11618                    .into_iter()
11619                    .map(|p| ("description__niew".to_owned(), p.to_string()))
11620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11621            ),
11622            _ => local_var_req_builder.query(&[(
11623                "description__niew",
11624                &local_var_str
11625                    .into_iter()
11626                    .map(|p| p.to_string())
11627                    .collect::<Vec<String>>()
11628                    .join(",")
11629                    .to_string(),
11630            )]),
11631        };
11632    }
11633    if let Some(ref local_var_str) = description__nisw {
11634        local_var_req_builder = match "multi" {
11635            "multi" => local_var_req_builder.query(
11636                &local_var_str
11637                    .into_iter()
11638                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
11639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11640            ),
11641            _ => local_var_req_builder.query(&[(
11642                "description__nisw",
11643                &local_var_str
11644                    .into_iter()
11645                    .map(|p| p.to_string())
11646                    .collect::<Vec<String>>()
11647                    .join(",")
11648                    .to_string(),
11649            )]),
11650        };
11651    }
11652    if let Some(ref local_var_str) = description__regex {
11653        local_var_req_builder = match "multi" {
11654            "multi" => local_var_req_builder.query(
11655                &local_var_str
11656                    .into_iter()
11657                    .map(|p| ("description__regex".to_owned(), p.to_string()))
11658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11659            ),
11660            _ => local_var_req_builder.query(&[(
11661                "description__regex",
11662                &local_var_str
11663                    .into_iter()
11664                    .map(|p| p.to_string())
11665                    .collect::<Vec<String>>()
11666                    .join(",")
11667                    .to_string(),
11668            )]),
11669        };
11670    }
11671    if let Some(ref local_var_str) = group {
11672        local_var_req_builder = match "multi" {
11673            "multi" => local_var_req_builder.query(
11674                &local_var_str
11675                    .into_iter()
11676                    .map(|p| ("group".to_owned(), p.to_string()))
11677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11678            ),
11679            _ => local_var_req_builder.query(&[(
11680                "group",
11681                &local_var_str
11682                    .into_iter()
11683                    .map(|p| p.to_string())
11684                    .collect::<Vec<String>>()
11685                    .join(",")
11686                    .to_string(),
11687            )]),
11688        };
11689    }
11690    if let Some(ref local_var_str) = group__n {
11691        local_var_req_builder = match "multi" {
11692            "multi" => local_var_req_builder.query(
11693                &local_var_str
11694                    .into_iter()
11695                    .map(|p| ("group__n".to_owned(), p.to_string()))
11696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11697            ),
11698            _ => local_var_req_builder.query(&[(
11699                "group__n",
11700                &local_var_str
11701                    .into_iter()
11702                    .map(|p| p.to_string())
11703                    .collect::<Vec<String>>()
11704                    .join(",")
11705                    .to_string(),
11706            )]),
11707        };
11708    }
11709    if let Some(ref local_var_str) = group_id {
11710        local_var_req_builder = match "multi" {
11711            "multi" => local_var_req_builder.query(
11712                &local_var_str
11713                    .into_iter()
11714                    .map(|p| ("group_id".to_owned(), p.to_string()))
11715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11716            ),
11717            _ => local_var_req_builder.query(&[(
11718                "group_id",
11719                &local_var_str
11720                    .into_iter()
11721                    .map(|p| p.to_string())
11722                    .collect::<Vec<String>>()
11723                    .join(",")
11724                    .to_string(),
11725            )]),
11726        };
11727    }
11728    if let Some(ref local_var_str) = group_id__n {
11729        local_var_req_builder = match "multi" {
11730            "multi" => local_var_req_builder.query(
11731                &local_var_str
11732                    .into_iter()
11733                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
11734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11735            ),
11736            _ => local_var_req_builder.query(&[(
11737                "group_id__n",
11738                &local_var_str
11739                    .into_iter()
11740                    .map(|p| p.to_string())
11741                    .collect::<Vec<String>>()
11742                    .join(",")
11743                    .to_string(),
11744            )]),
11745        };
11746    }
11747    if let Some(ref local_var_str) = id {
11748        local_var_req_builder = match "multi" {
11749            "multi" => local_var_req_builder.query(
11750                &local_var_str
11751                    .into_iter()
11752                    .map(|p| ("id".to_owned(), p.to_string()))
11753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11754            ),
11755            _ => local_var_req_builder.query(&[(
11756                "id",
11757                &local_var_str
11758                    .into_iter()
11759                    .map(|p| p.to_string())
11760                    .collect::<Vec<String>>()
11761                    .join(",")
11762                    .to_string(),
11763            )]),
11764        };
11765    }
11766    if let Some(ref local_var_str) = id__empty {
11767        local_var_req_builder =
11768            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
11769    }
11770    if let Some(ref local_var_str) = id__gt {
11771        local_var_req_builder = match "multi" {
11772            "multi" => local_var_req_builder.query(
11773                &local_var_str
11774                    .into_iter()
11775                    .map(|p| ("id__gt".to_owned(), p.to_string()))
11776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11777            ),
11778            _ => local_var_req_builder.query(&[(
11779                "id__gt",
11780                &local_var_str
11781                    .into_iter()
11782                    .map(|p| p.to_string())
11783                    .collect::<Vec<String>>()
11784                    .join(",")
11785                    .to_string(),
11786            )]),
11787        };
11788    }
11789    if let Some(ref local_var_str) = id__gte {
11790        local_var_req_builder = match "multi" {
11791            "multi" => local_var_req_builder.query(
11792                &local_var_str
11793                    .into_iter()
11794                    .map(|p| ("id__gte".to_owned(), p.to_string()))
11795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11796            ),
11797            _ => local_var_req_builder.query(&[(
11798                "id__gte",
11799                &local_var_str
11800                    .into_iter()
11801                    .map(|p| p.to_string())
11802                    .collect::<Vec<String>>()
11803                    .join(",")
11804                    .to_string(),
11805            )]),
11806        };
11807    }
11808    if let Some(ref local_var_str) = id__lt {
11809        local_var_req_builder = match "multi" {
11810            "multi" => local_var_req_builder.query(
11811                &local_var_str
11812                    .into_iter()
11813                    .map(|p| ("id__lt".to_owned(), p.to_string()))
11814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11815            ),
11816            _ => local_var_req_builder.query(&[(
11817                "id__lt",
11818                &local_var_str
11819                    .into_iter()
11820                    .map(|p| p.to_string())
11821                    .collect::<Vec<String>>()
11822                    .join(",")
11823                    .to_string(),
11824            )]),
11825        };
11826    }
11827    if let Some(ref local_var_str) = id__lte {
11828        local_var_req_builder = match "multi" {
11829            "multi" => local_var_req_builder.query(
11830                &local_var_str
11831                    .into_iter()
11832                    .map(|p| ("id__lte".to_owned(), p.to_string()))
11833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11834            ),
11835            _ => local_var_req_builder.query(&[(
11836                "id__lte",
11837                &local_var_str
11838                    .into_iter()
11839                    .map(|p| p.to_string())
11840                    .collect::<Vec<String>>()
11841                    .join(",")
11842                    .to_string(),
11843            )]),
11844        };
11845    }
11846    if let Some(ref local_var_str) = id__n {
11847        local_var_req_builder = match "multi" {
11848            "multi" => local_var_req_builder.query(
11849                &local_var_str
11850                    .into_iter()
11851                    .map(|p| ("id__n".to_owned(), p.to_string()))
11852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11853            ),
11854            _ => local_var_req_builder.query(&[(
11855                "id__n",
11856                &local_var_str
11857                    .into_iter()
11858                    .map(|p| p.to_string())
11859                    .collect::<Vec<String>>()
11860                    .join(",")
11861                    .to_string(),
11862            )]),
11863        };
11864    }
11865    if let Some(ref local_var_str) = last_updated {
11866        local_var_req_builder = match "multi" {
11867            "multi" => local_var_req_builder.query(
11868                &local_var_str
11869                    .into_iter()
11870                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11872            ),
11873            _ => local_var_req_builder.query(&[(
11874                "last_updated",
11875                &local_var_str
11876                    .into_iter()
11877                    .map(|p| p.to_string())
11878                    .collect::<Vec<String>>()
11879                    .join(",")
11880                    .to_string(),
11881            )]),
11882        };
11883    }
11884    if let Some(ref local_var_str) = last_updated__empty {
11885        local_var_req_builder = match "multi" {
11886            "multi" => local_var_req_builder.query(
11887                &local_var_str
11888                    .into_iter()
11889                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11891            ),
11892            _ => local_var_req_builder.query(&[(
11893                "last_updated__empty",
11894                &local_var_str
11895                    .into_iter()
11896                    .map(|p| p.to_string())
11897                    .collect::<Vec<String>>()
11898                    .join(",")
11899                    .to_string(),
11900            )]),
11901        };
11902    }
11903    if let Some(ref local_var_str) = last_updated__gt {
11904        local_var_req_builder = match "multi" {
11905            "multi" => local_var_req_builder.query(
11906                &local_var_str
11907                    .into_iter()
11908                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11910            ),
11911            _ => local_var_req_builder.query(&[(
11912                "last_updated__gt",
11913                &local_var_str
11914                    .into_iter()
11915                    .map(|p| p.to_string())
11916                    .collect::<Vec<String>>()
11917                    .join(",")
11918                    .to_string(),
11919            )]),
11920        };
11921    }
11922    if let Some(ref local_var_str) = last_updated__gte {
11923        local_var_req_builder = match "multi" {
11924            "multi" => local_var_req_builder.query(
11925                &local_var_str
11926                    .into_iter()
11927                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11929            ),
11930            _ => local_var_req_builder.query(&[(
11931                "last_updated__gte",
11932                &local_var_str
11933                    .into_iter()
11934                    .map(|p| p.to_string())
11935                    .collect::<Vec<String>>()
11936                    .join(",")
11937                    .to_string(),
11938            )]),
11939        };
11940    }
11941    if let Some(ref local_var_str) = last_updated__lt {
11942        local_var_req_builder = match "multi" {
11943            "multi" => local_var_req_builder.query(
11944                &local_var_str
11945                    .into_iter()
11946                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11948            ),
11949            _ => local_var_req_builder.query(&[(
11950                "last_updated__lt",
11951                &local_var_str
11952                    .into_iter()
11953                    .map(|p| p.to_string())
11954                    .collect::<Vec<String>>()
11955                    .join(",")
11956                    .to_string(),
11957            )]),
11958        };
11959    }
11960    if let Some(ref local_var_str) = last_updated__lte {
11961        local_var_req_builder = match "multi" {
11962            "multi" => local_var_req_builder.query(
11963                &local_var_str
11964                    .into_iter()
11965                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11967            ),
11968            _ => local_var_req_builder.query(&[(
11969                "last_updated__lte",
11970                &local_var_str
11971                    .into_iter()
11972                    .map(|p| p.to_string())
11973                    .collect::<Vec<String>>()
11974                    .join(",")
11975                    .to_string(),
11976            )]),
11977        };
11978    }
11979    if let Some(ref local_var_str) = last_updated__n {
11980        local_var_req_builder = match "multi" {
11981            "multi" => local_var_req_builder.query(
11982                &local_var_str
11983                    .into_iter()
11984                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11986            ),
11987            _ => local_var_req_builder.query(&[(
11988                "last_updated__n",
11989                &local_var_str
11990                    .into_iter()
11991                    .map(|p| p.to_string())
11992                    .collect::<Vec<String>>()
11993                    .join(",")
11994                    .to_string(),
11995            )]),
11996        };
11997    }
11998    if let Some(ref local_var_str) = limit {
11999        local_var_req_builder =
12000            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12001    }
12002    if let Some(ref local_var_str) = modified_by_request {
12003        local_var_req_builder =
12004            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
12005    }
12006    if let Some(ref local_var_str) = name {
12007        local_var_req_builder = match "multi" {
12008            "multi" => local_var_req_builder.query(
12009                &local_var_str
12010                    .into_iter()
12011                    .map(|p| ("name".to_owned(), p.to_string()))
12012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12013            ),
12014            _ => local_var_req_builder.query(&[(
12015                "name",
12016                &local_var_str
12017                    .into_iter()
12018                    .map(|p| p.to_string())
12019                    .collect::<Vec<String>>()
12020                    .join(",")
12021                    .to_string(),
12022            )]),
12023        };
12024    }
12025    if let Some(ref local_var_str) = name__empty {
12026        local_var_req_builder =
12027            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
12028    }
12029    if let Some(ref local_var_str) = name__ic {
12030        local_var_req_builder = match "multi" {
12031            "multi" => local_var_req_builder.query(
12032                &local_var_str
12033                    .into_iter()
12034                    .map(|p| ("name__ic".to_owned(), p.to_string()))
12035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12036            ),
12037            _ => local_var_req_builder.query(&[(
12038                "name__ic",
12039                &local_var_str
12040                    .into_iter()
12041                    .map(|p| p.to_string())
12042                    .collect::<Vec<String>>()
12043                    .join(",")
12044                    .to_string(),
12045            )]),
12046        };
12047    }
12048    if let Some(ref local_var_str) = name__ie {
12049        local_var_req_builder = match "multi" {
12050            "multi" => local_var_req_builder.query(
12051                &local_var_str
12052                    .into_iter()
12053                    .map(|p| ("name__ie".to_owned(), p.to_string()))
12054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12055            ),
12056            _ => local_var_req_builder.query(&[(
12057                "name__ie",
12058                &local_var_str
12059                    .into_iter()
12060                    .map(|p| p.to_string())
12061                    .collect::<Vec<String>>()
12062                    .join(",")
12063                    .to_string(),
12064            )]),
12065        };
12066    }
12067    if let Some(ref local_var_str) = name__iew {
12068        local_var_req_builder = match "multi" {
12069            "multi" => local_var_req_builder.query(
12070                &local_var_str
12071                    .into_iter()
12072                    .map(|p| ("name__iew".to_owned(), p.to_string()))
12073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12074            ),
12075            _ => local_var_req_builder.query(&[(
12076                "name__iew",
12077                &local_var_str
12078                    .into_iter()
12079                    .map(|p| p.to_string())
12080                    .collect::<Vec<String>>()
12081                    .join(",")
12082                    .to_string(),
12083            )]),
12084        };
12085    }
12086    if let Some(ref local_var_str) = name__iregex {
12087        local_var_req_builder = match "multi" {
12088            "multi" => local_var_req_builder.query(
12089                &local_var_str
12090                    .into_iter()
12091                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
12092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12093            ),
12094            _ => local_var_req_builder.query(&[(
12095                "name__iregex",
12096                &local_var_str
12097                    .into_iter()
12098                    .map(|p| p.to_string())
12099                    .collect::<Vec<String>>()
12100                    .join(",")
12101                    .to_string(),
12102            )]),
12103        };
12104    }
12105    if let Some(ref local_var_str) = name__isw {
12106        local_var_req_builder = match "multi" {
12107            "multi" => local_var_req_builder.query(
12108                &local_var_str
12109                    .into_iter()
12110                    .map(|p| ("name__isw".to_owned(), p.to_string()))
12111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12112            ),
12113            _ => local_var_req_builder.query(&[(
12114                "name__isw",
12115                &local_var_str
12116                    .into_iter()
12117                    .map(|p| p.to_string())
12118                    .collect::<Vec<String>>()
12119                    .join(",")
12120                    .to_string(),
12121            )]),
12122        };
12123    }
12124    if let Some(ref local_var_str) = name__n {
12125        local_var_req_builder = match "multi" {
12126            "multi" => local_var_req_builder.query(
12127                &local_var_str
12128                    .into_iter()
12129                    .map(|p| ("name__n".to_owned(), p.to_string()))
12130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12131            ),
12132            _ => local_var_req_builder.query(&[(
12133                "name__n",
12134                &local_var_str
12135                    .into_iter()
12136                    .map(|p| p.to_string())
12137                    .collect::<Vec<String>>()
12138                    .join(",")
12139                    .to_string(),
12140            )]),
12141        };
12142    }
12143    if let Some(ref local_var_str) = name__nic {
12144        local_var_req_builder = match "multi" {
12145            "multi" => local_var_req_builder.query(
12146                &local_var_str
12147                    .into_iter()
12148                    .map(|p| ("name__nic".to_owned(), p.to_string()))
12149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12150            ),
12151            _ => local_var_req_builder.query(&[(
12152                "name__nic",
12153                &local_var_str
12154                    .into_iter()
12155                    .map(|p| p.to_string())
12156                    .collect::<Vec<String>>()
12157                    .join(",")
12158                    .to_string(),
12159            )]),
12160        };
12161    }
12162    if let Some(ref local_var_str) = name__nie {
12163        local_var_req_builder = match "multi" {
12164            "multi" => local_var_req_builder.query(
12165                &local_var_str
12166                    .into_iter()
12167                    .map(|p| ("name__nie".to_owned(), p.to_string()))
12168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12169            ),
12170            _ => local_var_req_builder.query(&[(
12171                "name__nie",
12172                &local_var_str
12173                    .into_iter()
12174                    .map(|p| p.to_string())
12175                    .collect::<Vec<String>>()
12176                    .join(",")
12177                    .to_string(),
12178            )]),
12179        };
12180    }
12181    if let Some(ref local_var_str) = name__niew {
12182        local_var_req_builder = match "multi" {
12183            "multi" => local_var_req_builder.query(
12184                &local_var_str
12185                    .into_iter()
12186                    .map(|p| ("name__niew".to_owned(), p.to_string()))
12187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12188            ),
12189            _ => local_var_req_builder.query(&[(
12190                "name__niew",
12191                &local_var_str
12192                    .into_iter()
12193                    .map(|p| p.to_string())
12194                    .collect::<Vec<String>>()
12195                    .join(",")
12196                    .to_string(),
12197            )]),
12198        };
12199    }
12200    if let Some(ref local_var_str) = name__nisw {
12201        local_var_req_builder = match "multi" {
12202            "multi" => local_var_req_builder.query(
12203                &local_var_str
12204                    .into_iter()
12205                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
12206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12207            ),
12208            _ => local_var_req_builder.query(&[(
12209                "name__nisw",
12210                &local_var_str
12211                    .into_iter()
12212                    .map(|p| p.to_string())
12213                    .collect::<Vec<String>>()
12214                    .join(",")
12215                    .to_string(),
12216            )]),
12217        };
12218    }
12219    if let Some(ref local_var_str) = name__regex {
12220        local_var_req_builder = match "multi" {
12221            "multi" => local_var_req_builder.query(
12222                &local_var_str
12223                    .into_iter()
12224                    .map(|p| ("name__regex".to_owned(), p.to_string()))
12225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12226            ),
12227            _ => local_var_req_builder.query(&[(
12228                "name__regex",
12229                &local_var_str
12230                    .into_iter()
12231                    .map(|p| p.to_string())
12232                    .collect::<Vec<String>>()
12233                    .join(",")
12234                    .to_string(),
12235            )]),
12236        };
12237    }
12238    if let Some(ref local_var_str) = offset {
12239        local_var_req_builder =
12240            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12241    }
12242    if let Some(ref local_var_str) = ordering {
12243        local_var_req_builder =
12244            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
12245    }
12246    if let Some(ref local_var_str) = owner {
12247        local_var_req_builder = match "multi" {
12248            "multi" => local_var_req_builder.query(
12249                &local_var_str
12250                    .into_iter()
12251                    .map(|p| ("owner".to_owned(), p.to_string()))
12252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12253            ),
12254            _ => local_var_req_builder.query(&[(
12255                "owner",
12256                &local_var_str
12257                    .into_iter()
12258                    .map(|p| p.to_string())
12259                    .collect::<Vec<String>>()
12260                    .join(",")
12261                    .to_string(),
12262            )]),
12263        };
12264    }
12265    if let Some(ref local_var_str) = owner__n {
12266        local_var_req_builder = match "multi" {
12267            "multi" => local_var_req_builder.query(
12268                &local_var_str
12269                    .into_iter()
12270                    .map(|p| ("owner__n".to_owned(), p.to_string()))
12271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12272            ),
12273            _ => local_var_req_builder.query(&[(
12274                "owner__n",
12275                &local_var_str
12276                    .into_iter()
12277                    .map(|p| p.to_string())
12278                    .collect::<Vec<String>>()
12279                    .join(",")
12280                    .to_string(),
12281            )]),
12282        };
12283    }
12284    if let Some(ref local_var_str) = owner_group {
12285        local_var_req_builder = match "multi" {
12286            "multi" => local_var_req_builder.query(
12287                &local_var_str
12288                    .into_iter()
12289                    .map(|p| ("owner_group".to_owned(), p.to_string()))
12290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12291            ),
12292            _ => local_var_req_builder.query(&[(
12293                "owner_group",
12294                &local_var_str
12295                    .into_iter()
12296                    .map(|p| p.to_string())
12297                    .collect::<Vec<String>>()
12298                    .join(",")
12299                    .to_string(),
12300            )]),
12301        };
12302    }
12303    if let Some(ref local_var_str) = owner_group__n {
12304        local_var_req_builder = match "multi" {
12305            "multi" => local_var_req_builder.query(
12306                &local_var_str
12307                    .into_iter()
12308                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
12309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12310            ),
12311            _ => local_var_req_builder.query(&[(
12312                "owner_group__n",
12313                &local_var_str
12314                    .into_iter()
12315                    .map(|p| p.to_string())
12316                    .collect::<Vec<String>>()
12317                    .join(",")
12318                    .to_string(),
12319            )]),
12320        };
12321    }
12322    if let Some(ref local_var_str) = owner_group_id {
12323        local_var_req_builder = match "multi" {
12324            "multi" => local_var_req_builder.query(
12325                &local_var_str
12326                    .into_iter()
12327                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
12328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12329            ),
12330            _ => local_var_req_builder.query(&[(
12331                "owner_group_id",
12332                &local_var_str
12333                    .into_iter()
12334                    .map(|p| p.to_string())
12335                    .collect::<Vec<String>>()
12336                    .join(",")
12337                    .to_string(),
12338            )]),
12339        };
12340    }
12341    if let Some(ref local_var_str) = owner_group_id__n {
12342        local_var_req_builder = match "multi" {
12343            "multi" => local_var_req_builder.query(
12344                &local_var_str
12345                    .into_iter()
12346                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
12347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12348            ),
12349            _ => local_var_req_builder.query(&[(
12350                "owner_group_id__n",
12351                &local_var_str
12352                    .into_iter()
12353                    .map(|p| p.to_string())
12354                    .collect::<Vec<String>>()
12355                    .join(",")
12356                    .to_string(),
12357            )]),
12358        };
12359    }
12360    if let Some(ref local_var_str) = owner_id {
12361        local_var_req_builder = match "multi" {
12362            "multi" => local_var_req_builder.query(
12363                &local_var_str
12364                    .into_iter()
12365                    .map(|p| ("owner_id".to_owned(), p.to_string()))
12366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12367            ),
12368            _ => local_var_req_builder.query(&[(
12369                "owner_id",
12370                &local_var_str
12371                    .into_iter()
12372                    .map(|p| p.to_string())
12373                    .collect::<Vec<String>>()
12374                    .join(",")
12375                    .to_string(),
12376            )]),
12377        };
12378    }
12379    if let Some(ref local_var_str) = owner_id__n {
12380        local_var_req_builder = match "multi" {
12381            "multi" => local_var_req_builder.query(
12382                &local_var_str
12383                    .into_iter()
12384                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
12385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12386            ),
12387            _ => local_var_req_builder.query(&[(
12388                "owner_id__n",
12389                &local_var_str
12390                    .into_iter()
12391                    .map(|p| p.to_string())
12392                    .collect::<Vec<String>>()
12393                    .join(",")
12394                    .to_string(),
12395            )]),
12396        };
12397    }
12398    if let Some(ref local_var_str) = q {
12399        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12400    }
12401    if let Some(ref local_var_str) = slug {
12402        local_var_req_builder = match "multi" {
12403            "multi" => local_var_req_builder.query(
12404                &local_var_str
12405                    .into_iter()
12406                    .map(|p| ("slug".to_owned(), p.to_string()))
12407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12408            ),
12409            _ => local_var_req_builder.query(&[(
12410                "slug",
12411                &local_var_str
12412                    .into_iter()
12413                    .map(|p| p.to_string())
12414                    .collect::<Vec<String>>()
12415                    .join(",")
12416                    .to_string(),
12417            )]),
12418        };
12419    }
12420    if let Some(ref local_var_str) = slug__empty {
12421        local_var_req_builder =
12422            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
12423    }
12424    if let Some(ref local_var_str) = slug__ic {
12425        local_var_req_builder = match "multi" {
12426            "multi" => local_var_req_builder.query(
12427                &local_var_str
12428                    .into_iter()
12429                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
12430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12431            ),
12432            _ => local_var_req_builder.query(&[(
12433                "slug__ic",
12434                &local_var_str
12435                    .into_iter()
12436                    .map(|p| p.to_string())
12437                    .collect::<Vec<String>>()
12438                    .join(",")
12439                    .to_string(),
12440            )]),
12441        };
12442    }
12443    if let Some(ref local_var_str) = slug__ie {
12444        local_var_req_builder = match "multi" {
12445            "multi" => local_var_req_builder.query(
12446                &local_var_str
12447                    .into_iter()
12448                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
12449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12450            ),
12451            _ => local_var_req_builder.query(&[(
12452                "slug__ie",
12453                &local_var_str
12454                    .into_iter()
12455                    .map(|p| p.to_string())
12456                    .collect::<Vec<String>>()
12457                    .join(",")
12458                    .to_string(),
12459            )]),
12460        };
12461    }
12462    if let Some(ref local_var_str) = slug__iew {
12463        local_var_req_builder = match "multi" {
12464            "multi" => local_var_req_builder.query(
12465                &local_var_str
12466                    .into_iter()
12467                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
12468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12469            ),
12470            _ => local_var_req_builder.query(&[(
12471                "slug__iew",
12472                &local_var_str
12473                    .into_iter()
12474                    .map(|p| p.to_string())
12475                    .collect::<Vec<String>>()
12476                    .join(",")
12477                    .to_string(),
12478            )]),
12479        };
12480    }
12481    if let Some(ref local_var_str) = slug__iregex {
12482        local_var_req_builder = match "multi" {
12483            "multi" => local_var_req_builder.query(
12484                &local_var_str
12485                    .into_iter()
12486                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
12487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12488            ),
12489            _ => local_var_req_builder.query(&[(
12490                "slug__iregex",
12491                &local_var_str
12492                    .into_iter()
12493                    .map(|p| p.to_string())
12494                    .collect::<Vec<String>>()
12495                    .join(",")
12496                    .to_string(),
12497            )]),
12498        };
12499    }
12500    if let Some(ref local_var_str) = slug__isw {
12501        local_var_req_builder = match "multi" {
12502            "multi" => local_var_req_builder.query(
12503                &local_var_str
12504                    .into_iter()
12505                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
12506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12507            ),
12508            _ => local_var_req_builder.query(&[(
12509                "slug__isw",
12510                &local_var_str
12511                    .into_iter()
12512                    .map(|p| p.to_string())
12513                    .collect::<Vec<String>>()
12514                    .join(",")
12515                    .to_string(),
12516            )]),
12517        };
12518    }
12519    if let Some(ref local_var_str) = slug__n {
12520        local_var_req_builder = match "multi" {
12521            "multi" => local_var_req_builder.query(
12522                &local_var_str
12523                    .into_iter()
12524                    .map(|p| ("slug__n".to_owned(), p.to_string()))
12525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12526            ),
12527            _ => local_var_req_builder.query(&[(
12528                "slug__n",
12529                &local_var_str
12530                    .into_iter()
12531                    .map(|p| p.to_string())
12532                    .collect::<Vec<String>>()
12533                    .join(",")
12534                    .to_string(),
12535            )]),
12536        };
12537    }
12538    if let Some(ref local_var_str) = slug__nic {
12539        local_var_req_builder = match "multi" {
12540            "multi" => local_var_req_builder.query(
12541                &local_var_str
12542                    .into_iter()
12543                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
12544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12545            ),
12546            _ => local_var_req_builder.query(&[(
12547                "slug__nic",
12548                &local_var_str
12549                    .into_iter()
12550                    .map(|p| p.to_string())
12551                    .collect::<Vec<String>>()
12552                    .join(",")
12553                    .to_string(),
12554            )]),
12555        };
12556    }
12557    if let Some(ref local_var_str) = slug__nie {
12558        local_var_req_builder = match "multi" {
12559            "multi" => local_var_req_builder.query(
12560                &local_var_str
12561                    .into_iter()
12562                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
12563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12564            ),
12565            _ => local_var_req_builder.query(&[(
12566                "slug__nie",
12567                &local_var_str
12568                    .into_iter()
12569                    .map(|p| p.to_string())
12570                    .collect::<Vec<String>>()
12571                    .join(",")
12572                    .to_string(),
12573            )]),
12574        };
12575    }
12576    if let Some(ref local_var_str) = slug__niew {
12577        local_var_req_builder = match "multi" {
12578            "multi" => local_var_req_builder.query(
12579                &local_var_str
12580                    .into_iter()
12581                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
12582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12583            ),
12584            _ => local_var_req_builder.query(&[(
12585                "slug__niew",
12586                &local_var_str
12587                    .into_iter()
12588                    .map(|p| p.to_string())
12589                    .collect::<Vec<String>>()
12590                    .join(",")
12591                    .to_string(),
12592            )]),
12593        };
12594    }
12595    if let Some(ref local_var_str) = slug__nisw {
12596        local_var_req_builder = match "multi" {
12597            "multi" => local_var_req_builder.query(
12598                &local_var_str
12599                    .into_iter()
12600                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
12601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12602            ),
12603            _ => local_var_req_builder.query(&[(
12604                "slug__nisw",
12605                &local_var_str
12606                    .into_iter()
12607                    .map(|p| p.to_string())
12608                    .collect::<Vec<String>>()
12609                    .join(",")
12610                    .to_string(),
12611            )]),
12612        };
12613    }
12614    if let Some(ref local_var_str) = slug__regex {
12615        local_var_req_builder = match "multi" {
12616            "multi" => local_var_req_builder.query(
12617                &local_var_str
12618                    .into_iter()
12619                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
12620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12621            ),
12622            _ => local_var_req_builder.query(&[(
12623                "slug__regex",
12624                &local_var_str
12625                    .into_iter()
12626                    .map(|p| p.to_string())
12627                    .collect::<Vec<String>>()
12628                    .join(",")
12629                    .to_string(),
12630            )]),
12631        };
12632    }
12633    if let Some(ref local_var_str) = tag {
12634        local_var_req_builder = match "multi" {
12635            "multi" => local_var_req_builder.query(
12636                &local_var_str
12637                    .into_iter()
12638                    .map(|p| ("tag".to_owned(), p.to_string()))
12639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12640            ),
12641            _ => local_var_req_builder.query(&[(
12642                "tag",
12643                &local_var_str
12644                    .into_iter()
12645                    .map(|p| p.to_string())
12646                    .collect::<Vec<String>>()
12647                    .join(",")
12648                    .to_string(),
12649            )]),
12650        };
12651    }
12652    if let Some(ref local_var_str) = tag__n {
12653        local_var_req_builder = match "multi" {
12654            "multi" => local_var_req_builder.query(
12655                &local_var_str
12656                    .into_iter()
12657                    .map(|p| ("tag__n".to_owned(), p.to_string()))
12658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12659            ),
12660            _ => local_var_req_builder.query(&[(
12661                "tag__n",
12662                &local_var_str
12663                    .into_iter()
12664                    .map(|p| p.to_string())
12665                    .collect::<Vec<String>>()
12666                    .join(",")
12667                    .to_string(),
12668            )]),
12669        };
12670    }
12671    if let Some(ref local_var_str) = tag_id {
12672        local_var_req_builder = match "multi" {
12673            "multi" => local_var_req_builder.query(
12674                &local_var_str
12675                    .into_iter()
12676                    .map(|p| ("tag_id".to_owned(), p.to_string()))
12677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12678            ),
12679            _ => local_var_req_builder.query(&[(
12680                "tag_id",
12681                &local_var_str
12682                    .into_iter()
12683                    .map(|p| p.to_string())
12684                    .collect::<Vec<String>>()
12685                    .join(",")
12686                    .to_string(),
12687            )]),
12688        };
12689    }
12690    if let Some(ref local_var_str) = tag_id__n {
12691        local_var_req_builder = match "multi" {
12692            "multi" => local_var_req_builder.query(
12693                &local_var_str
12694                    .into_iter()
12695                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
12696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12697            ),
12698            _ => local_var_req_builder.query(&[(
12699                "tag_id__n",
12700                &local_var_str
12701                    .into_iter()
12702                    .map(|p| p.to_string())
12703                    .collect::<Vec<String>>()
12704                    .join(",")
12705                    .to_string(),
12706            )]),
12707        };
12708    }
12709    if let Some(ref local_var_str) = updated_by_request {
12710        local_var_req_builder =
12711            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
12712    }
12713    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12714        local_var_req_builder =
12715            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12716    }
12717    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12718        let local_var_key = local_var_apikey.key.clone();
12719        let local_var_value = match local_var_apikey.prefix {
12720            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12721            None => local_var_key,
12722        };
12723        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12724    };
12725
12726    let local_var_req = local_var_req_builder.build()?;
12727    let local_var_resp = local_var_client.execute(local_var_req).await?;
12728
12729    let local_var_status = local_var_resp.status();
12730    let local_var_content = local_var_resp.text().await?;
12731
12732    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12733        serde_json::from_str(&local_var_content).map_err(Error::from)
12734    } else {
12735        let local_var_entity: Option<TenancyTenantsListError> =
12736            serde_json::from_str(&local_var_content).ok();
12737        let local_var_error = ResponseContent {
12738            status: local_var_status,
12739            content: local_var_content,
12740            entity: local_var_entity,
12741        };
12742        Err(Error::ResponseError(local_var_error))
12743    }
12744}
12745
12746/// Patch a tenant object.
12747pub async fn tenancy_tenants_partial_update(
12748    configuration: &configuration::Configuration,
12749    id: i32,
12750    patched_tenant_request: Option<crate::models::PatchedTenantRequest>,
12751) -> Result<crate::models::Tenant, Error<TenancyTenantsPartialUpdateError>> {
12752    let local_var_configuration = configuration;
12753
12754    let local_var_client = &local_var_configuration.client;
12755
12756    let local_var_uri_str = format!(
12757        "{}/api/tenancy/tenants/{id}/",
12758        local_var_configuration.base_path,
12759        id = id
12760    );
12761    let mut local_var_req_builder =
12762        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12763
12764    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12765        local_var_req_builder =
12766            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12767    }
12768    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12769        let local_var_key = local_var_apikey.key.clone();
12770        let local_var_value = match local_var_apikey.prefix {
12771            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12772            None => local_var_key,
12773        };
12774        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12775    };
12776    local_var_req_builder = local_var_req_builder.json(&patched_tenant_request);
12777
12778    let local_var_req = local_var_req_builder.build()?;
12779    let local_var_resp = local_var_client.execute(local_var_req).await?;
12780
12781    let local_var_status = local_var_resp.status();
12782    let local_var_content = local_var_resp.text().await?;
12783
12784    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12785        serde_json::from_str(&local_var_content).map_err(Error::from)
12786    } else {
12787        let local_var_entity: Option<TenancyTenantsPartialUpdateError> =
12788            serde_json::from_str(&local_var_content).ok();
12789        let local_var_error = ResponseContent {
12790            status: local_var_status,
12791            content: local_var_content,
12792            entity: local_var_entity,
12793        };
12794        Err(Error::ResponseError(local_var_error))
12795    }
12796}
12797
12798/// Get a tenant object.
12799pub async fn tenancy_tenants_retrieve(
12800    configuration: &configuration::Configuration,
12801    id: i32,
12802) -> Result<crate::models::Tenant, Error<TenancyTenantsRetrieveError>> {
12803    let local_var_configuration = configuration;
12804
12805    let local_var_client = &local_var_configuration.client;
12806
12807    let local_var_uri_str = format!(
12808        "{}/api/tenancy/tenants/{id}/",
12809        local_var_configuration.base_path,
12810        id = id
12811    );
12812    let mut local_var_req_builder =
12813        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12814
12815    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12816        local_var_req_builder =
12817            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12818    }
12819    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12820        let local_var_key = local_var_apikey.key.clone();
12821        let local_var_value = match local_var_apikey.prefix {
12822            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12823            None => local_var_key,
12824        };
12825        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12826    };
12827
12828    let local_var_req = local_var_req_builder.build()?;
12829    let local_var_resp = local_var_client.execute(local_var_req).await?;
12830
12831    let local_var_status = local_var_resp.status();
12832    let local_var_content = local_var_resp.text().await?;
12833
12834    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12835        serde_json::from_str(&local_var_content).map_err(Error::from)
12836    } else {
12837        let local_var_entity: Option<TenancyTenantsRetrieveError> =
12838            serde_json::from_str(&local_var_content).ok();
12839        let local_var_error = ResponseContent {
12840            status: local_var_status,
12841            content: local_var_content,
12842            entity: local_var_entity,
12843        };
12844        Err(Error::ResponseError(local_var_error))
12845    }
12846}
12847
12848/// Put a tenant object.
12849pub async fn tenancy_tenants_update(
12850    configuration: &configuration::Configuration,
12851    id: i32,
12852    tenant_request: crate::models::TenantRequest,
12853) -> Result<crate::models::Tenant, Error<TenancyTenantsUpdateError>> {
12854    let local_var_configuration = configuration;
12855
12856    let local_var_client = &local_var_configuration.client;
12857
12858    let local_var_uri_str = format!(
12859        "{}/api/tenancy/tenants/{id}/",
12860        local_var_configuration.base_path,
12861        id = id
12862    );
12863    let mut local_var_req_builder =
12864        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12865
12866    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12867        local_var_req_builder =
12868            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12869    }
12870    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12871        let local_var_key = local_var_apikey.key.clone();
12872        let local_var_value = match local_var_apikey.prefix {
12873            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12874            None => local_var_key,
12875        };
12876        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12877    };
12878    local_var_req_builder = local_var_req_builder.json(&tenant_request);
12879
12880    let local_var_req = local_var_req_builder.build()?;
12881    let local_var_resp = local_var_client.execute(local_var_req).await?;
12882
12883    let local_var_status = local_var_resp.status();
12884    let local_var_content = local_var_resp.text().await?;
12885
12886    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12887        serde_json::from_str(&local_var_content).map_err(Error::from)
12888    } else {
12889        let local_var_entity: Option<TenancyTenantsUpdateError> =
12890            serde_json::from_str(&local_var_content).ok();
12891        let local_var_error = ResponseContent {
12892            status: local_var_status,
12893            content: local_var_content,
12894            entity: local_var_entity,
12895        };
12896        Err(Error::ResponseError(local_var_error))
12897    }
12898}
netbox_openapi/apis/tenancy_api.rs

netbox_openapi/apis/
tenancy_api.rs
