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.6.0 (4.6)
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    start: Option<i32>,
713    tag: Option<Vec<String>>,
714    tag__n: Option<Vec<String>>,
715    tag_id: Option<Vec<i32>>,
716    tag_id__n: Option<Vec<i32>>,
717    updated_by_request: Option<&str>,
718) -> Result<crate::models::PaginatedContactAssignmentList, Error<TenancyContactAssignmentsListError>>
719{
720    let local_var_configuration = configuration;
721
722    let local_var_client = &local_var_configuration.client;
723
724    let local_var_uri_str = format!(
725        "{}/api/tenancy/contact-assignments/",
726        local_var_configuration.base_path
727    );
728    let mut local_var_req_builder =
729        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
730
731    if let Some(ref local_var_str) = contact_id {
732        local_var_req_builder = match "multi" {
733            "multi" => local_var_req_builder.query(
734                &local_var_str
735                    .into_iter()
736                    .map(|p| ("contact_id".to_owned(), p.to_string()))
737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
738            ),
739            _ => local_var_req_builder.query(&[(
740                "contact_id",
741                &local_var_str
742                    .into_iter()
743                    .map(|p| p.to_string())
744                    .collect::<Vec<String>>()
745                    .join(",")
746                    .to_string(),
747            )]),
748        };
749    }
750    if let Some(ref local_var_str) = contact_id__n {
751        local_var_req_builder = match "multi" {
752            "multi" => local_var_req_builder.query(
753                &local_var_str
754                    .into_iter()
755                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
757            ),
758            _ => local_var_req_builder.query(&[(
759                "contact_id__n",
760                &local_var_str
761                    .into_iter()
762                    .map(|p| p.to_string())
763                    .collect::<Vec<String>>()
764                    .join(",")
765                    .to_string(),
766            )]),
767        };
768    }
769    if let Some(ref local_var_str) = created {
770        local_var_req_builder = match "multi" {
771            "multi" => local_var_req_builder.query(
772                &local_var_str
773                    .into_iter()
774                    .map(|p| ("created".to_owned(), p.to_string()))
775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
776            ),
777            _ => local_var_req_builder.query(&[(
778                "created",
779                &local_var_str
780                    .into_iter()
781                    .map(|p| p.to_string())
782                    .collect::<Vec<String>>()
783                    .join(",")
784                    .to_string(),
785            )]),
786        };
787    }
788    if let Some(ref local_var_str) = created__empty {
789        local_var_req_builder = match "multi" {
790            "multi" => local_var_req_builder.query(
791                &local_var_str
792                    .into_iter()
793                    .map(|p| ("created__empty".to_owned(), p.to_string()))
794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
795            ),
796            _ => local_var_req_builder.query(&[(
797                "created__empty",
798                &local_var_str
799                    .into_iter()
800                    .map(|p| p.to_string())
801                    .collect::<Vec<String>>()
802                    .join(",")
803                    .to_string(),
804            )]),
805        };
806    }
807    if let Some(ref local_var_str) = created__gt {
808        local_var_req_builder = match "multi" {
809            "multi" => local_var_req_builder.query(
810                &local_var_str
811                    .into_iter()
812                    .map(|p| ("created__gt".to_owned(), p.to_string()))
813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
814            ),
815            _ => local_var_req_builder.query(&[(
816                "created__gt",
817                &local_var_str
818                    .into_iter()
819                    .map(|p| p.to_string())
820                    .collect::<Vec<String>>()
821                    .join(",")
822                    .to_string(),
823            )]),
824        };
825    }
826    if let Some(ref local_var_str) = created__gte {
827        local_var_req_builder = match "multi" {
828            "multi" => local_var_req_builder.query(
829                &local_var_str
830                    .into_iter()
831                    .map(|p| ("created__gte".to_owned(), p.to_string()))
832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
833            ),
834            _ => local_var_req_builder.query(&[(
835                "created__gte",
836                &local_var_str
837                    .into_iter()
838                    .map(|p| p.to_string())
839                    .collect::<Vec<String>>()
840                    .join(",")
841                    .to_string(),
842            )]),
843        };
844    }
845    if let Some(ref local_var_str) = created__lt {
846        local_var_req_builder = match "multi" {
847            "multi" => local_var_req_builder.query(
848                &local_var_str
849                    .into_iter()
850                    .map(|p| ("created__lt".to_owned(), p.to_string()))
851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
852            ),
853            _ => local_var_req_builder.query(&[(
854                "created__lt",
855                &local_var_str
856                    .into_iter()
857                    .map(|p| p.to_string())
858                    .collect::<Vec<String>>()
859                    .join(",")
860                    .to_string(),
861            )]),
862        };
863    }
864    if let Some(ref local_var_str) = created__lte {
865        local_var_req_builder = match "multi" {
866            "multi" => local_var_req_builder.query(
867                &local_var_str
868                    .into_iter()
869                    .map(|p| ("created__lte".to_owned(), p.to_string()))
870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
871            ),
872            _ => local_var_req_builder.query(&[(
873                "created__lte",
874                &local_var_str
875                    .into_iter()
876                    .map(|p| p.to_string())
877                    .collect::<Vec<String>>()
878                    .join(",")
879                    .to_string(),
880            )]),
881        };
882    }
883    if let Some(ref local_var_str) = created__n {
884        local_var_req_builder = match "multi" {
885            "multi" => local_var_req_builder.query(
886                &local_var_str
887                    .into_iter()
888                    .map(|p| ("created__n".to_owned(), p.to_string()))
889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
890            ),
891            _ => local_var_req_builder.query(&[(
892                "created__n",
893                &local_var_str
894                    .into_iter()
895                    .map(|p| p.to_string())
896                    .collect::<Vec<String>>()
897                    .join(",")
898                    .to_string(),
899            )]),
900        };
901    }
902    if let Some(ref local_var_str) = created_by_request {
903        local_var_req_builder =
904            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
905    }
906    if let Some(ref local_var_str) = group {
907        local_var_req_builder = match "multi" {
908            "multi" => local_var_req_builder.query(
909                &local_var_str
910                    .into_iter()
911                    .map(|p| ("group".to_owned(), p.to_string()))
912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
913            ),
914            _ => local_var_req_builder.query(&[(
915                "group",
916                &local_var_str
917                    .into_iter()
918                    .map(|p| p.to_string())
919                    .collect::<Vec<String>>()
920                    .join(",")
921                    .to_string(),
922            )]),
923        };
924    }
925    if let Some(ref local_var_str) = group__n {
926        local_var_req_builder = match "multi" {
927            "multi" => local_var_req_builder.query(
928                &local_var_str
929                    .into_iter()
930                    .map(|p| ("group__n".to_owned(), p.to_string()))
931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
932            ),
933            _ => local_var_req_builder.query(&[(
934                "group__n",
935                &local_var_str
936                    .into_iter()
937                    .map(|p| p.to_string())
938                    .collect::<Vec<String>>()
939                    .join(",")
940                    .to_string(),
941            )]),
942        };
943    }
944    if let Some(ref local_var_str) = group_id {
945        local_var_req_builder = match "multi" {
946            "multi" => local_var_req_builder.query(
947                &local_var_str
948                    .into_iter()
949                    .map(|p| ("group_id".to_owned(), p.to_string()))
950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
951            ),
952            _ => local_var_req_builder.query(&[(
953                "group_id",
954                &local_var_str
955                    .into_iter()
956                    .map(|p| p.to_string())
957                    .collect::<Vec<String>>()
958                    .join(",")
959                    .to_string(),
960            )]),
961        };
962    }
963    if let Some(ref local_var_str) = group_id__n {
964        local_var_req_builder = match "multi" {
965            "multi" => local_var_req_builder.query(
966                &local_var_str
967                    .into_iter()
968                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
970            ),
971            _ => local_var_req_builder.query(&[(
972                "group_id__n",
973                &local_var_str
974                    .into_iter()
975                    .map(|p| p.to_string())
976                    .collect::<Vec<String>>()
977                    .join(",")
978                    .to_string(),
979            )]),
980        };
981    }
982    if let Some(ref local_var_str) = id {
983        local_var_req_builder = match "multi" {
984            "multi" => local_var_req_builder.query(
985                &local_var_str
986                    .into_iter()
987                    .map(|p| ("id".to_owned(), p.to_string()))
988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
989            ),
990            _ => local_var_req_builder.query(&[(
991                "id",
992                &local_var_str
993                    .into_iter()
994                    .map(|p| p.to_string())
995                    .collect::<Vec<String>>()
996                    .join(",")
997                    .to_string(),
998            )]),
999        };
1000    }
1001    if let Some(ref local_var_str) = id__empty {
1002        local_var_req_builder =
1003            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1004    }
1005    if let Some(ref local_var_str) = id__gt {
1006        local_var_req_builder = match "multi" {
1007            "multi" => local_var_req_builder.query(
1008                &local_var_str
1009                    .into_iter()
1010                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1012            ),
1013            _ => local_var_req_builder.query(&[(
1014                "id__gt",
1015                &local_var_str
1016                    .into_iter()
1017                    .map(|p| p.to_string())
1018                    .collect::<Vec<String>>()
1019                    .join(",")
1020                    .to_string(),
1021            )]),
1022        };
1023    }
1024    if let Some(ref local_var_str) = id__gte {
1025        local_var_req_builder = match "multi" {
1026            "multi" => local_var_req_builder.query(
1027                &local_var_str
1028                    .into_iter()
1029                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1031            ),
1032            _ => local_var_req_builder.query(&[(
1033                "id__gte",
1034                &local_var_str
1035                    .into_iter()
1036                    .map(|p| p.to_string())
1037                    .collect::<Vec<String>>()
1038                    .join(",")
1039                    .to_string(),
1040            )]),
1041        };
1042    }
1043    if let Some(ref local_var_str) = id__lt {
1044        local_var_req_builder = match "multi" {
1045            "multi" => local_var_req_builder.query(
1046                &local_var_str
1047                    .into_iter()
1048                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1050            ),
1051            _ => local_var_req_builder.query(&[(
1052                "id__lt",
1053                &local_var_str
1054                    .into_iter()
1055                    .map(|p| p.to_string())
1056                    .collect::<Vec<String>>()
1057                    .join(",")
1058                    .to_string(),
1059            )]),
1060        };
1061    }
1062    if let Some(ref local_var_str) = id__lte {
1063        local_var_req_builder = match "multi" {
1064            "multi" => local_var_req_builder.query(
1065                &local_var_str
1066                    .into_iter()
1067                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1069            ),
1070            _ => local_var_req_builder.query(&[(
1071                "id__lte",
1072                &local_var_str
1073                    .into_iter()
1074                    .map(|p| p.to_string())
1075                    .collect::<Vec<String>>()
1076                    .join(",")
1077                    .to_string(),
1078            )]),
1079        };
1080    }
1081    if let Some(ref local_var_str) = id__n {
1082        local_var_req_builder = match "multi" {
1083            "multi" => local_var_req_builder.query(
1084                &local_var_str
1085                    .into_iter()
1086                    .map(|p| ("id__n".to_owned(), p.to_string()))
1087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1088            ),
1089            _ => local_var_req_builder.query(&[(
1090                "id__n",
1091                &local_var_str
1092                    .into_iter()
1093                    .map(|p| p.to_string())
1094                    .collect::<Vec<String>>()
1095                    .join(",")
1096                    .to_string(),
1097            )]),
1098        };
1099    }
1100    if let Some(ref local_var_str) = last_updated {
1101        local_var_req_builder = match "multi" {
1102            "multi" => local_var_req_builder.query(
1103                &local_var_str
1104                    .into_iter()
1105                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1107            ),
1108            _ => local_var_req_builder.query(&[(
1109                "last_updated",
1110                &local_var_str
1111                    .into_iter()
1112                    .map(|p| p.to_string())
1113                    .collect::<Vec<String>>()
1114                    .join(",")
1115                    .to_string(),
1116            )]),
1117        };
1118    }
1119    if let Some(ref local_var_str) = last_updated__empty {
1120        local_var_req_builder = match "multi" {
1121            "multi" => local_var_req_builder.query(
1122                &local_var_str
1123                    .into_iter()
1124                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1126            ),
1127            _ => local_var_req_builder.query(&[(
1128                "last_updated__empty",
1129                &local_var_str
1130                    .into_iter()
1131                    .map(|p| p.to_string())
1132                    .collect::<Vec<String>>()
1133                    .join(",")
1134                    .to_string(),
1135            )]),
1136        };
1137    }
1138    if let Some(ref local_var_str) = last_updated__gt {
1139        local_var_req_builder = match "multi" {
1140            "multi" => local_var_req_builder.query(
1141                &local_var_str
1142                    .into_iter()
1143                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1145            ),
1146            _ => local_var_req_builder.query(&[(
1147                "last_updated__gt",
1148                &local_var_str
1149                    .into_iter()
1150                    .map(|p| p.to_string())
1151                    .collect::<Vec<String>>()
1152                    .join(",")
1153                    .to_string(),
1154            )]),
1155        };
1156    }
1157    if let Some(ref local_var_str) = last_updated__gte {
1158        local_var_req_builder = match "multi" {
1159            "multi" => local_var_req_builder.query(
1160                &local_var_str
1161                    .into_iter()
1162                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1164            ),
1165            _ => local_var_req_builder.query(&[(
1166                "last_updated__gte",
1167                &local_var_str
1168                    .into_iter()
1169                    .map(|p| p.to_string())
1170                    .collect::<Vec<String>>()
1171                    .join(",")
1172                    .to_string(),
1173            )]),
1174        };
1175    }
1176    if let Some(ref local_var_str) = last_updated__lt {
1177        local_var_req_builder = match "multi" {
1178            "multi" => local_var_req_builder.query(
1179                &local_var_str
1180                    .into_iter()
1181                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1183            ),
1184            _ => local_var_req_builder.query(&[(
1185                "last_updated__lt",
1186                &local_var_str
1187                    .into_iter()
1188                    .map(|p| p.to_string())
1189                    .collect::<Vec<String>>()
1190                    .join(",")
1191                    .to_string(),
1192            )]),
1193        };
1194    }
1195    if let Some(ref local_var_str) = last_updated__lte {
1196        local_var_req_builder = match "multi" {
1197            "multi" => local_var_req_builder.query(
1198                &local_var_str
1199                    .into_iter()
1200                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1202            ),
1203            _ => local_var_req_builder.query(&[(
1204                "last_updated__lte",
1205                &local_var_str
1206                    .into_iter()
1207                    .map(|p| p.to_string())
1208                    .collect::<Vec<String>>()
1209                    .join(",")
1210                    .to_string(),
1211            )]),
1212        };
1213    }
1214    if let Some(ref local_var_str) = last_updated__n {
1215        local_var_req_builder = match "multi" {
1216            "multi" => local_var_req_builder.query(
1217                &local_var_str
1218                    .into_iter()
1219                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1221            ),
1222            _ => local_var_req_builder.query(&[(
1223                "last_updated__n",
1224                &local_var_str
1225                    .into_iter()
1226                    .map(|p| p.to_string())
1227                    .collect::<Vec<String>>()
1228                    .join(",")
1229                    .to_string(),
1230            )]),
1231        };
1232    }
1233    if let Some(ref local_var_str) = limit {
1234        local_var_req_builder =
1235            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1236    }
1237    if let Some(ref local_var_str) = modified_by_request {
1238        local_var_req_builder =
1239            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1240    }
1241    if let Some(ref local_var_str) = object_id {
1242        local_var_req_builder = match "multi" {
1243            "multi" => local_var_req_builder.query(
1244                &local_var_str
1245                    .into_iter()
1246                    .map(|p| ("object_id".to_owned(), p.to_string()))
1247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1248            ),
1249            _ => local_var_req_builder.query(&[(
1250                "object_id",
1251                &local_var_str
1252                    .into_iter()
1253                    .map(|p| p.to_string())
1254                    .collect::<Vec<String>>()
1255                    .join(",")
1256                    .to_string(),
1257            )]),
1258        };
1259    }
1260    if let Some(ref local_var_str) = object_id__empty {
1261        local_var_req_builder =
1262            local_var_req_builder.query(&[("object_id__empty", &local_var_str.to_string())]);
1263    }
1264    if let Some(ref local_var_str) = object_id__gt {
1265        local_var_req_builder = match "multi" {
1266            "multi" => local_var_req_builder.query(
1267                &local_var_str
1268                    .into_iter()
1269                    .map(|p| ("object_id__gt".to_owned(), p.to_string()))
1270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1271            ),
1272            _ => local_var_req_builder.query(&[(
1273                "object_id__gt",
1274                &local_var_str
1275                    .into_iter()
1276                    .map(|p| p.to_string())
1277                    .collect::<Vec<String>>()
1278                    .join(",")
1279                    .to_string(),
1280            )]),
1281        };
1282    }
1283    if let Some(ref local_var_str) = object_id__gte {
1284        local_var_req_builder = match "multi" {
1285            "multi" => local_var_req_builder.query(
1286                &local_var_str
1287                    .into_iter()
1288                    .map(|p| ("object_id__gte".to_owned(), p.to_string()))
1289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1290            ),
1291            _ => local_var_req_builder.query(&[(
1292                "object_id__gte",
1293                &local_var_str
1294                    .into_iter()
1295                    .map(|p| p.to_string())
1296                    .collect::<Vec<String>>()
1297                    .join(",")
1298                    .to_string(),
1299            )]),
1300        };
1301    }
1302    if let Some(ref local_var_str) = object_id__lt {
1303        local_var_req_builder = match "multi" {
1304            "multi" => local_var_req_builder.query(
1305                &local_var_str
1306                    .into_iter()
1307                    .map(|p| ("object_id__lt".to_owned(), p.to_string()))
1308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1309            ),
1310            _ => local_var_req_builder.query(&[(
1311                "object_id__lt",
1312                &local_var_str
1313                    .into_iter()
1314                    .map(|p| p.to_string())
1315                    .collect::<Vec<String>>()
1316                    .join(",")
1317                    .to_string(),
1318            )]),
1319        };
1320    }
1321    if let Some(ref local_var_str) = object_id__lte {
1322        local_var_req_builder = match "multi" {
1323            "multi" => local_var_req_builder.query(
1324                &local_var_str
1325                    .into_iter()
1326                    .map(|p| ("object_id__lte".to_owned(), p.to_string()))
1327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1328            ),
1329            _ => local_var_req_builder.query(&[(
1330                "object_id__lte",
1331                &local_var_str
1332                    .into_iter()
1333                    .map(|p| p.to_string())
1334                    .collect::<Vec<String>>()
1335                    .join(",")
1336                    .to_string(),
1337            )]),
1338        };
1339    }
1340    if let Some(ref local_var_str) = object_id__n {
1341        local_var_req_builder = match "multi" {
1342            "multi" => local_var_req_builder.query(
1343                &local_var_str
1344                    .into_iter()
1345                    .map(|p| ("object_id__n".to_owned(), p.to_string()))
1346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1347            ),
1348            _ => local_var_req_builder.query(&[(
1349                "object_id__n",
1350                &local_var_str
1351                    .into_iter()
1352                    .map(|p| p.to_string())
1353                    .collect::<Vec<String>>()
1354                    .join(",")
1355                    .to_string(),
1356            )]),
1357        };
1358    }
1359    if let Some(ref local_var_str) = object_type {
1360        local_var_req_builder = match "multi" {
1361            "multi" => local_var_req_builder.query(
1362                &local_var_str
1363                    .into_iter()
1364                    .map(|p| ("object_type".to_owned(), p.to_string()))
1365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1366            ),
1367            _ => local_var_req_builder.query(&[(
1368                "object_type",
1369                &local_var_str
1370                    .into_iter()
1371                    .map(|p| p.to_string())
1372                    .collect::<Vec<String>>()
1373                    .join(",")
1374                    .to_string(),
1375            )]),
1376        };
1377    }
1378    if let Some(ref local_var_str) = object_type__n {
1379        local_var_req_builder = match "multi" {
1380            "multi" => local_var_req_builder.query(
1381                &local_var_str
1382                    .into_iter()
1383                    .map(|p| ("object_type__n".to_owned(), p.to_string()))
1384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1385            ),
1386            _ => local_var_req_builder.query(&[(
1387                "object_type__n",
1388                &local_var_str
1389                    .into_iter()
1390                    .map(|p| p.to_string())
1391                    .collect::<Vec<String>>()
1392                    .join(",")
1393                    .to_string(),
1394            )]),
1395        };
1396    }
1397    if let Some(ref local_var_str) = object_type_id {
1398        local_var_req_builder =
1399            local_var_req_builder.query(&[("object_type_id", &local_var_str.to_string())]);
1400    }
1401    if let Some(ref local_var_str) = object_type_id__n {
1402        local_var_req_builder =
1403            local_var_req_builder.query(&[("object_type_id__n", &local_var_str.to_string())]);
1404    }
1405    if let Some(ref local_var_str) = offset {
1406        local_var_req_builder =
1407            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1408    }
1409    if let Some(ref local_var_str) = ordering {
1410        local_var_req_builder =
1411            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1412    }
1413    if let Some(ref local_var_str) = priority {
1414        local_var_req_builder =
1415            local_var_req_builder.query(&[("priority", &local_var_str.to_string())]);
1416    }
1417    if let Some(ref local_var_str) = priority__empty {
1418        local_var_req_builder =
1419            local_var_req_builder.query(&[("priority__empty", &local_var_str.to_string())]);
1420    }
1421    if let Some(ref local_var_str) = priority__ic {
1422        local_var_req_builder = match "multi" {
1423            "multi" => local_var_req_builder.query(
1424                &local_var_str
1425                    .into_iter()
1426                    .map(|p| ("priority__ic".to_owned(), p.to_string()))
1427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1428            ),
1429            _ => local_var_req_builder.query(&[(
1430                "priority__ic",
1431                &local_var_str
1432                    .into_iter()
1433                    .map(|p| p.to_string())
1434                    .collect::<Vec<String>>()
1435                    .join(",")
1436                    .to_string(),
1437            )]),
1438        };
1439    }
1440    if let Some(ref local_var_str) = priority__ie {
1441        local_var_req_builder = match "multi" {
1442            "multi" => local_var_req_builder.query(
1443                &local_var_str
1444                    .into_iter()
1445                    .map(|p| ("priority__ie".to_owned(), p.to_string()))
1446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1447            ),
1448            _ => local_var_req_builder.query(&[(
1449                "priority__ie",
1450                &local_var_str
1451                    .into_iter()
1452                    .map(|p| p.to_string())
1453                    .collect::<Vec<String>>()
1454                    .join(",")
1455                    .to_string(),
1456            )]),
1457        };
1458    }
1459    if let Some(ref local_var_str) = priority__iew {
1460        local_var_req_builder = match "multi" {
1461            "multi" => local_var_req_builder.query(
1462                &local_var_str
1463                    .into_iter()
1464                    .map(|p| ("priority__iew".to_owned(), p.to_string()))
1465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1466            ),
1467            _ => local_var_req_builder.query(&[(
1468                "priority__iew",
1469                &local_var_str
1470                    .into_iter()
1471                    .map(|p| p.to_string())
1472                    .collect::<Vec<String>>()
1473                    .join(",")
1474                    .to_string(),
1475            )]),
1476        };
1477    }
1478    if let Some(ref local_var_str) = priority__iregex {
1479        local_var_req_builder = match "multi" {
1480            "multi" => local_var_req_builder.query(
1481                &local_var_str
1482                    .into_iter()
1483                    .map(|p| ("priority__iregex".to_owned(), p.to_string()))
1484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1485            ),
1486            _ => local_var_req_builder.query(&[(
1487                "priority__iregex",
1488                &local_var_str
1489                    .into_iter()
1490                    .map(|p| p.to_string())
1491                    .collect::<Vec<String>>()
1492                    .join(",")
1493                    .to_string(),
1494            )]),
1495        };
1496    }
1497    if let Some(ref local_var_str) = priority__isw {
1498        local_var_req_builder = match "multi" {
1499            "multi" => local_var_req_builder.query(
1500                &local_var_str
1501                    .into_iter()
1502                    .map(|p| ("priority__isw".to_owned(), p.to_string()))
1503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1504            ),
1505            _ => local_var_req_builder.query(&[(
1506                "priority__isw",
1507                &local_var_str
1508                    .into_iter()
1509                    .map(|p| p.to_string())
1510                    .collect::<Vec<String>>()
1511                    .join(",")
1512                    .to_string(),
1513            )]),
1514        };
1515    }
1516    if let Some(ref local_var_str) = priority__n {
1517        local_var_req_builder =
1518            local_var_req_builder.query(&[("priority__n", &local_var_str.to_string())]);
1519    }
1520    if let Some(ref local_var_str) = priority__nic {
1521        local_var_req_builder = match "multi" {
1522            "multi" => local_var_req_builder.query(
1523                &local_var_str
1524                    .into_iter()
1525                    .map(|p| ("priority__nic".to_owned(), p.to_string()))
1526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1527            ),
1528            _ => local_var_req_builder.query(&[(
1529                "priority__nic",
1530                &local_var_str
1531                    .into_iter()
1532                    .map(|p| p.to_string())
1533                    .collect::<Vec<String>>()
1534                    .join(",")
1535                    .to_string(),
1536            )]),
1537        };
1538    }
1539    if let Some(ref local_var_str) = priority__nie {
1540        local_var_req_builder = match "multi" {
1541            "multi" => local_var_req_builder.query(
1542                &local_var_str
1543                    .into_iter()
1544                    .map(|p| ("priority__nie".to_owned(), p.to_string()))
1545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1546            ),
1547            _ => local_var_req_builder.query(&[(
1548                "priority__nie",
1549                &local_var_str
1550                    .into_iter()
1551                    .map(|p| p.to_string())
1552                    .collect::<Vec<String>>()
1553                    .join(",")
1554                    .to_string(),
1555            )]),
1556        };
1557    }
1558    if let Some(ref local_var_str) = priority__niew {
1559        local_var_req_builder = match "multi" {
1560            "multi" => local_var_req_builder.query(
1561                &local_var_str
1562                    .into_iter()
1563                    .map(|p| ("priority__niew".to_owned(), p.to_string()))
1564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1565            ),
1566            _ => local_var_req_builder.query(&[(
1567                "priority__niew",
1568                &local_var_str
1569                    .into_iter()
1570                    .map(|p| p.to_string())
1571                    .collect::<Vec<String>>()
1572                    .join(",")
1573                    .to_string(),
1574            )]),
1575        };
1576    }
1577    if let Some(ref local_var_str) = priority__nisw {
1578        local_var_req_builder = match "multi" {
1579            "multi" => local_var_req_builder.query(
1580                &local_var_str
1581                    .into_iter()
1582                    .map(|p| ("priority__nisw".to_owned(), p.to_string()))
1583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1584            ),
1585            _ => local_var_req_builder.query(&[(
1586                "priority__nisw",
1587                &local_var_str
1588                    .into_iter()
1589                    .map(|p| p.to_string())
1590                    .collect::<Vec<String>>()
1591                    .join(",")
1592                    .to_string(),
1593            )]),
1594        };
1595    }
1596    if let Some(ref local_var_str) = priority__regex {
1597        local_var_req_builder = match "multi" {
1598            "multi" => local_var_req_builder.query(
1599                &local_var_str
1600                    .into_iter()
1601                    .map(|p| ("priority__regex".to_owned(), p.to_string()))
1602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1603            ),
1604            _ => local_var_req_builder.query(&[(
1605                "priority__regex",
1606                &local_var_str
1607                    .into_iter()
1608                    .map(|p| p.to_string())
1609                    .collect::<Vec<String>>()
1610                    .join(",")
1611                    .to_string(),
1612            )]),
1613        };
1614    }
1615    if let Some(ref local_var_str) = q {
1616        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1617    }
1618    if let Some(ref local_var_str) = role {
1619        local_var_req_builder = match "multi" {
1620            "multi" => local_var_req_builder.query(
1621                &local_var_str
1622                    .into_iter()
1623                    .map(|p| ("role".to_owned(), p.to_string()))
1624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1625            ),
1626            _ => local_var_req_builder.query(&[(
1627                "role",
1628                &local_var_str
1629                    .into_iter()
1630                    .map(|p| p.to_string())
1631                    .collect::<Vec<String>>()
1632                    .join(",")
1633                    .to_string(),
1634            )]),
1635        };
1636    }
1637    if let Some(ref local_var_str) = role__n {
1638        local_var_req_builder = match "multi" {
1639            "multi" => local_var_req_builder.query(
1640                &local_var_str
1641                    .into_iter()
1642                    .map(|p| ("role__n".to_owned(), p.to_string()))
1643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1644            ),
1645            _ => local_var_req_builder.query(&[(
1646                "role__n",
1647                &local_var_str
1648                    .into_iter()
1649                    .map(|p| p.to_string())
1650                    .collect::<Vec<String>>()
1651                    .join(",")
1652                    .to_string(),
1653            )]),
1654        };
1655    }
1656    if let Some(ref local_var_str) = role_id {
1657        local_var_req_builder = match "multi" {
1658            "multi" => local_var_req_builder.query(
1659                &local_var_str
1660                    .into_iter()
1661                    .map(|p| ("role_id".to_owned(), p.to_string()))
1662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1663            ),
1664            _ => local_var_req_builder.query(&[(
1665                "role_id",
1666                &local_var_str
1667                    .into_iter()
1668                    .map(|p| p.to_string())
1669                    .collect::<Vec<String>>()
1670                    .join(",")
1671                    .to_string(),
1672            )]),
1673        };
1674    }
1675    if let Some(ref local_var_str) = role_id__n {
1676        local_var_req_builder = match "multi" {
1677            "multi" => local_var_req_builder.query(
1678                &local_var_str
1679                    .into_iter()
1680                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
1681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1682            ),
1683            _ => local_var_req_builder.query(&[(
1684                "role_id__n",
1685                &local_var_str
1686                    .into_iter()
1687                    .map(|p| p.to_string())
1688                    .collect::<Vec<String>>()
1689                    .join(",")
1690                    .to_string(),
1691            )]),
1692        };
1693    }
1694    if let Some(ref local_var_str) = start {
1695        local_var_req_builder =
1696            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
1697    }
1698    if let Some(ref local_var_str) = tag {
1699        local_var_req_builder = match "multi" {
1700            "multi" => local_var_req_builder.query(
1701                &local_var_str
1702                    .into_iter()
1703                    .map(|p| ("tag".to_owned(), p.to_string()))
1704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1705            ),
1706            _ => local_var_req_builder.query(&[(
1707                "tag",
1708                &local_var_str
1709                    .into_iter()
1710                    .map(|p| p.to_string())
1711                    .collect::<Vec<String>>()
1712                    .join(",")
1713                    .to_string(),
1714            )]),
1715        };
1716    }
1717    if let Some(ref local_var_str) = tag__n {
1718        local_var_req_builder = match "multi" {
1719            "multi" => local_var_req_builder.query(
1720                &local_var_str
1721                    .into_iter()
1722                    .map(|p| ("tag__n".to_owned(), p.to_string()))
1723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1724            ),
1725            _ => local_var_req_builder.query(&[(
1726                "tag__n",
1727                &local_var_str
1728                    .into_iter()
1729                    .map(|p| p.to_string())
1730                    .collect::<Vec<String>>()
1731                    .join(",")
1732                    .to_string(),
1733            )]),
1734        };
1735    }
1736    if let Some(ref local_var_str) = tag_id {
1737        local_var_req_builder = match "multi" {
1738            "multi" => local_var_req_builder.query(
1739                &local_var_str
1740                    .into_iter()
1741                    .map(|p| ("tag_id".to_owned(), p.to_string()))
1742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1743            ),
1744            _ => local_var_req_builder.query(&[(
1745                "tag_id",
1746                &local_var_str
1747                    .into_iter()
1748                    .map(|p| p.to_string())
1749                    .collect::<Vec<String>>()
1750                    .join(",")
1751                    .to_string(),
1752            )]),
1753        };
1754    }
1755    if let Some(ref local_var_str) = tag_id__n {
1756        local_var_req_builder = match "multi" {
1757            "multi" => local_var_req_builder.query(
1758                &local_var_str
1759                    .into_iter()
1760                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
1761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1762            ),
1763            _ => local_var_req_builder.query(&[(
1764                "tag_id__n",
1765                &local_var_str
1766                    .into_iter()
1767                    .map(|p| p.to_string())
1768                    .collect::<Vec<String>>()
1769                    .join(",")
1770                    .to_string(),
1771            )]),
1772        };
1773    }
1774    if let Some(ref local_var_str) = updated_by_request {
1775        local_var_req_builder =
1776            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
1777    }
1778    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1779        local_var_req_builder =
1780            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1781    }
1782    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1783        let local_var_key = local_var_apikey.key.clone();
1784        let local_var_value = match local_var_apikey.prefix {
1785            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1786            None => local_var_key,
1787        };
1788        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1789    };
1790
1791    let local_var_req = local_var_req_builder.build()?;
1792    let local_var_resp = local_var_client.execute(local_var_req).await?;
1793
1794    let local_var_status = local_var_resp.status();
1795    let local_var_content = local_var_resp.text().await?;
1796
1797    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1798        serde_json::from_str(&local_var_content).map_err(Error::from)
1799    } else {
1800        let local_var_entity: Option<TenancyContactAssignmentsListError> =
1801            serde_json::from_str(&local_var_content).ok();
1802        let local_var_error = ResponseContent {
1803            status: local_var_status,
1804            content: local_var_content,
1805            entity: local_var_entity,
1806        };
1807        Err(Error::ResponseError(local_var_error))
1808    }
1809}
1810
1811/// Patch a contact assignment object.
1812pub async fn tenancy_contact_assignments_partial_update(
1813    configuration: &configuration::Configuration,
1814    id: i32,
1815    patched_writable_contact_assignment_request: Option<
1816        crate::models::PatchedWritableContactAssignmentRequest,
1817    >,
1818) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsPartialUpdateError>> {
1819    let local_var_configuration = configuration;
1820
1821    let local_var_client = &local_var_configuration.client;
1822
1823    let local_var_uri_str = format!(
1824        "{}/api/tenancy/contact-assignments/{id}/",
1825        local_var_configuration.base_path,
1826        id = id
1827    );
1828    let mut local_var_req_builder =
1829        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1830
1831    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1832        local_var_req_builder =
1833            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1834    }
1835    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1836        let local_var_key = local_var_apikey.key.clone();
1837        let local_var_value = match local_var_apikey.prefix {
1838            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1839            None => local_var_key,
1840        };
1841        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1842    };
1843    local_var_req_builder =
1844        local_var_req_builder.json(&patched_writable_contact_assignment_request);
1845
1846    let local_var_req = local_var_req_builder.build()?;
1847    let local_var_resp = local_var_client.execute(local_var_req).await?;
1848
1849    let local_var_status = local_var_resp.status();
1850    let local_var_content = local_var_resp.text().await?;
1851
1852    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1853        serde_json::from_str(&local_var_content).map_err(Error::from)
1854    } else {
1855        let local_var_entity: Option<TenancyContactAssignmentsPartialUpdateError> =
1856            serde_json::from_str(&local_var_content).ok();
1857        let local_var_error = ResponseContent {
1858            status: local_var_status,
1859            content: local_var_content,
1860            entity: local_var_entity,
1861        };
1862        Err(Error::ResponseError(local_var_error))
1863    }
1864}
1865
1866/// Get a contact assignment object.
1867pub async fn tenancy_contact_assignments_retrieve(
1868    configuration: &configuration::Configuration,
1869    id: i32,
1870) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsRetrieveError>> {
1871    let local_var_configuration = configuration;
1872
1873    let local_var_client = &local_var_configuration.client;
1874
1875    let local_var_uri_str = format!(
1876        "{}/api/tenancy/contact-assignments/{id}/",
1877        local_var_configuration.base_path,
1878        id = id
1879    );
1880    let mut local_var_req_builder =
1881        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1882
1883    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1884        local_var_req_builder =
1885            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1886    }
1887    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1888        let local_var_key = local_var_apikey.key.clone();
1889        let local_var_value = match local_var_apikey.prefix {
1890            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1891            None => local_var_key,
1892        };
1893        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1894    };
1895
1896    let local_var_req = local_var_req_builder.build()?;
1897    let local_var_resp = local_var_client.execute(local_var_req).await?;
1898
1899    let local_var_status = local_var_resp.status();
1900    let local_var_content = local_var_resp.text().await?;
1901
1902    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1903        serde_json::from_str(&local_var_content).map_err(Error::from)
1904    } else {
1905        let local_var_entity: Option<TenancyContactAssignmentsRetrieveError> =
1906            serde_json::from_str(&local_var_content).ok();
1907        let local_var_error = ResponseContent {
1908            status: local_var_status,
1909            content: local_var_content,
1910            entity: local_var_entity,
1911        };
1912        Err(Error::ResponseError(local_var_error))
1913    }
1914}
1915
1916/// Put a contact assignment object.
1917pub async fn tenancy_contact_assignments_update(
1918    configuration: &configuration::Configuration,
1919    id: i32,
1920    writable_contact_assignment_request: crate::models::WritableContactAssignmentRequest,
1921) -> Result<crate::models::ContactAssignment, Error<TenancyContactAssignmentsUpdateError>> {
1922    let local_var_configuration = configuration;
1923
1924    let local_var_client = &local_var_configuration.client;
1925
1926    let local_var_uri_str = format!(
1927        "{}/api/tenancy/contact-assignments/{id}/",
1928        local_var_configuration.base_path,
1929        id = id
1930    );
1931    let mut local_var_req_builder =
1932        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1933
1934    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1935        local_var_req_builder =
1936            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1937    }
1938    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1939        let local_var_key = local_var_apikey.key.clone();
1940        let local_var_value = match local_var_apikey.prefix {
1941            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1942            None => local_var_key,
1943        };
1944        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1945    };
1946    local_var_req_builder = local_var_req_builder.json(&writable_contact_assignment_request);
1947
1948    let local_var_req = local_var_req_builder.build()?;
1949    let local_var_resp = local_var_client.execute(local_var_req).await?;
1950
1951    let local_var_status = local_var_resp.status();
1952    let local_var_content = local_var_resp.text().await?;
1953
1954    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1955        serde_json::from_str(&local_var_content).map_err(Error::from)
1956    } else {
1957        let local_var_entity: Option<TenancyContactAssignmentsUpdateError> =
1958            serde_json::from_str(&local_var_content).ok();
1959        let local_var_error = ResponseContent {
1960            status: local_var_status,
1961            content: local_var_content,
1962            entity: local_var_entity,
1963        };
1964        Err(Error::ResponseError(local_var_error))
1965    }
1966}
1967
1968/// Delete a list of contact group objects.
1969pub async fn tenancy_contact_groups_bulk_destroy(
1970    configuration: &configuration::Configuration,
1971    contact_group_request: Vec<crate::models::ContactGroupRequest>,
1972) -> Result<(), Error<TenancyContactGroupsBulkDestroyError>> {
1973    let local_var_configuration = configuration;
1974
1975    let local_var_client = &local_var_configuration.client;
1976
1977    let local_var_uri_str = format!(
1978        "{}/api/tenancy/contact-groups/",
1979        local_var_configuration.base_path
1980    );
1981    let mut local_var_req_builder =
1982        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1983
1984    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1985        local_var_req_builder =
1986            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1987    }
1988    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1989        let local_var_key = local_var_apikey.key.clone();
1990        let local_var_value = match local_var_apikey.prefix {
1991            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1992            None => local_var_key,
1993        };
1994        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1995    };
1996    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
1997
1998    let local_var_req = local_var_req_builder.build()?;
1999    let local_var_resp = local_var_client.execute(local_var_req).await?;
2000
2001    let local_var_status = local_var_resp.status();
2002    let local_var_content = local_var_resp.text().await?;
2003
2004    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2005        Ok(())
2006    } else {
2007        let local_var_entity: Option<TenancyContactGroupsBulkDestroyError> =
2008            serde_json::from_str(&local_var_content).ok();
2009        let local_var_error = ResponseContent {
2010            status: local_var_status,
2011            content: local_var_content,
2012            entity: local_var_entity,
2013        };
2014        Err(Error::ResponseError(local_var_error))
2015    }
2016}
2017
2018/// Patch a list of contact group objects.
2019pub async fn tenancy_contact_groups_bulk_partial_update(
2020    configuration: &configuration::Configuration,
2021    contact_group_request: Vec<crate::models::ContactGroupRequest>,
2022) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkPartialUpdateError>> {
2023    let local_var_configuration = configuration;
2024
2025    let local_var_client = &local_var_configuration.client;
2026
2027    let local_var_uri_str = format!(
2028        "{}/api/tenancy/contact-groups/",
2029        local_var_configuration.base_path
2030    );
2031    let mut local_var_req_builder =
2032        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2033
2034    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2035        local_var_req_builder =
2036            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2037    }
2038    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2039        let local_var_key = local_var_apikey.key.clone();
2040        let local_var_value = match local_var_apikey.prefix {
2041            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2042            None => local_var_key,
2043        };
2044        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2045    };
2046    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
2047
2048    let local_var_req = local_var_req_builder.build()?;
2049    let local_var_resp = local_var_client.execute(local_var_req).await?;
2050
2051    let local_var_status = local_var_resp.status();
2052    let local_var_content = local_var_resp.text().await?;
2053
2054    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2055        serde_json::from_str(&local_var_content).map_err(Error::from)
2056    } else {
2057        let local_var_entity: Option<TenancyContactGroupsBulkPartialUpdateError> =
2058            serde_json::from_str(&local_var_content).ok();
2059        let local_var_error = ResponseContent {
2060            status: local_var_status,
2061            content: local_var_content,
2062            entity: local_var_entity,
2063        };
2064        Err(Error::ResponseError(local_var_error))
2065    }
2066}
2067
2068/// Put a list of contact group objects.
2069pub async fn tenancy_contact_groups_bulk_update(
2070    configuration: &configuration::Configuration,
2071    contact_group_request: Vec<crate::models::ContactGroupRequest>,
2072) -> Result<Vec<crate::models::ContactGroup>, Error<TenancyContactGroupsBulkUpdateError>> {
2073    let local_var_configuration = configuration;
2074
2075    let local_var_client = &local_var_configuration.client;
2076
2077    let local_var_uri_str = format!(
2078        "{}/api/tenancy/contact-groups/",
2079        local_var_configuration.base_path
2080    );
2081    let mut local_var_req_builder =
2082        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2083
2084    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2085        local_var_req_builder =
2086            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2087    }
2088    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2089        let local_var_key = local_var_apikey.key.clone();
2090        let local_var_value = match local_var_apikey.prefix {
2091            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2092            None => local_var_key,
2093        };
2094        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2095    };
2096    local_var_req_builder = local_var_req_builder.json(&contact_group_request);
2097
2098    let local_var_req = local_var_req_builder.build()?;
2099    let local_var_resp = local_var_client.execute(local_var_req).await?;
2100
2101    let local_var_status = local_var_resp.status();
2102    let local_var_content = local_var_resp.text().await?;
2103
2104    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2105        serde_json::from_str(&local_var_content).map_err(Error::from)
2106    } else {
2107        let local_var_entity: Option<TenancyContactGroupsBulkUpdateError> =
2108            serde_json::from_str(&local_var_content).ok();
2109        let local_var_error = ResponseContent {
2110            status: local_var_status,
2111            content: local_var_content,
2112            entity: local_var_entity,
2113        };
2114        Err(Error::ResponseError(local_var_error))
2115    }
2116}
2117
2118/// Post a list of contact group objects.
2119pub async fn tenancy_contact_groups_create(
2120    configuration: &configuration::Configuration,
2121    tenancy_contact_groups_create_request: crate::models::TenancyContactGroupsCreateRequest,
2122) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsCreateError>> {
2123    let local_var_configuration = configuration;
2124
2125    let local_var_client = &local_var_configuration.client;
2126
2127    let local_var_uri_str = format!(
2128        "{}/api/tenancy/contact-groups/",
2129        local_var_configuration.base_path
2130    );
2131    let mut local_var_req_builder =
2132        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2133
2134    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2135        local_var_req_builder =
2136            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2137    }
2138    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2139        let local_var_key = local_var_apikey.key.clone();
2140        let local_var_value = match local_var_apikey.prefix {
2141            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2142            None => local_var_key,
2143        };
2144        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2145    };
2146    local_var_req_builder = local_var_req_builder.json(&tenancy_contact_groups_create_request);
2147
2148    let local_var_req = local_var_req_builder.build()?;
2149    let local_var_resp = local_var_client.execute(local_var_req).await?;
2150
2151    let local_var_status = local_var_resp.status();
2152    let local_var_content = local_var_resp.text().await?;
2153
2154    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2155        serde_json::from_str(&local_var_content).map_err(Error::from)
2156    } else {
2157        let local_var_entity: Option<TenancyContactGroupsCreateError> =
2158            serde_json::from_str(&local_var_content).ok();
2159        let local_var_error = ResponseContent {
2160            status: local_var_status,
2161            content: local_var_content,
2162            entity: local_var_entity,
2163        };
2164        Err(Error::ResponseError(local_var_error))
2165    }
2166}
2167
2168/// Delete a contact group object.
2169pub async fn tenancy_contact_groups_destroy(
2170    configuration: &configuration::Configuration,
2171    id: i32,
2172) -> Result<(), Error<TenancyContactGroupsDestroyError>> {
2173    let local_var_configuration = configuration;
2174
2175    let local_var_client = &local_var_configuration.client;
2176
2177    let local_var_uri_str = format!(
2178        "{}/api/tenancy/contact-groups/{id}/",
2179        local_var_configuration.base_path,
2180        id = id
2181    );
2182    let mut local_var_req_builder =
2183        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2184
2185    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2186        local_var_req_builder =
2187            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2188    }
2189    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2190        let local_var_key = local_var_apikey.key.clone();
2191        let local_var_value = match local_var_apikey.prefix {
2192            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2193            None => local_var_key,
2194        };
2195        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2196    };
2197
2198    let local_var_req = local_var_req_builder.build()?;
2199    let local_var_resp = local_var_client.execute(local_var_req).await?;
2200
2201    let local_var_status = local_var_resp.status();
2202    let local_var_content = local_var_resp.text().await?;
2203
2204    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2205        Ok(())
2206    } else {
2207        let local_var_entity: Option<TenancyContactGroupsDestroyError> =
2208            serde_json::from_str(&local_var_content).ok();
2209        let local_var_error = ResponseContent {
2210            status: local_var_status,
2211            content: local_var_content,
2212            entity: local_var_entity,
2213        };
2214        Err(Error::ResponseError(local_var_error))
2215    }
2216}
2217
2218/// Get a list of contact group objects.
2219pub async fn tenancy_contact_groups_list(
2220    configuration: &configuration::Configuration,
2221    ancestor: Option<Vec<String>>,
2222    ancestor__n: Option<Vec<String>>,
2223    ancestor_id: Option<Vec<String>>,
2224    ancestor_id__n: Option<Vec<String>>,
2225    contact_id: Option<Vec<i32>>,
2226    contact_id__n: Option<Vec<i32>>,
2227    created: Option<Vec<String>>,
2228    created__empty: Option<Vec<String>>,
2229    created__gt: Option<Vec<String>>,
2230    created__gte: Option<Vec<String>>,
2231    created__lt: Option<Vec<String>>,
2232    created__lte: Option<Vec<String>>,
2233    created__n: Option<Vec<String>>,
2234    created_by_request: Option<&str>,
2235    description: Option<Vec<String>>,
2236    description__empty: Option<bool>,
2237    description__ic: Option<Vec<String>>,
2238    description__ie: Option<Vec<String>>,
2239    description__iew: Option<Vec<String>>,
2240    description__iregex: Option<Vec<String>>,
2241    description__isw: Option<Vec<String>>,
2242    description__n: Option<Vec<String>>,
2243    description__nic: Option<Vec<String>>,
2244    description__nie: Option<Vec<String>>,
2245    description__niew: Option<Vec<String>>,
2246    description__nisw: Option<Vec<String>>,
2247    description__regex: Option<Vec<String>>,
2248    id: Option<Vec<i32>>,
2249    id__empty: Option<bool>,
2250    id__gt: Option<Vec<i32>>,
2251    id__gte: Option<Vec<i32>>,
2252    id__lt: Option<Vec<i32>>,
2253    id__lte: Option<Vec<i32>>,
2254    id__n: Option<Vec<i32>>,
2255    last_updated: Option<Vec<String>>,
2256    last_updated__empty: Option<Vec<String>>,
2257    last_updated__gt: Option<Vec<String>>,
2258    last_updated__gte: Option<Vec<String>>,
2259    last_updated__lt: Option<Vec<String>>,
2260    last_updated__lte: Option<Vec<String>>,
2261    last_updated__n: Option<Vec<String>>,
2262    limit: Option<i32>,
2263    modified_by_request: Option<&str>,
2264    name: Option<Vec<String>>,
2265    name__empty: Option<bool>,
2266    name__ic: Option<Vec<String>>,
2267    name__ie: Option<Vec<String>>,
2268    name__iew: Option<Vec<String>>,
2269    name__iregex: Option<Vec<String>>,
2270    name__isw: Option<Vec<String>>,
2271    name__n: Option<Vec<String>>,
2272    name__nic: Option<Vec<String>>,
2273    name__nie: Option<Vec<String>>,
2274    name__niew: Option<Vec<String>>,
2275    name__nisw: Option<Vec<String>>,
2276    name__regex: Option<Vec<String>>,
2277    offset: Option<i32>,
2278    ordering: Option<&str>,
2279    owner: Option<Vec<String>>,
2280    owner__n: Option<Vec<String>>,
2281    owner_group: Option<Vec<String>>,
2282    owner_group__n: Option<Vec<String>>,
2283    owner_group_id: Option<Vec<i32>>,
2284    owner_group_id__n: Option<Vec<i32>>,
2285    owner_id: Option<Vec<i32>>,
2286    owner_id__n: Option<Vec<i32>>,
2287    parent: Option<Vec<String>>,
2288    parent__n: Option<Vec<String>>,
2289    parent_id: Option<Vec<i32>>,
2290    parent_id__n: Option<Vec<i32>>,
2291    q: Option<&str>,
2292    slug: Option<Vec<String>>,
2293    slug__empty: Option<bool>,
2294    slug__ic: Option<Vec<String>>,
2295    slug__ie: Option<Vec<String>>,
2296    slug__iew: Option<Vec<String>>,
2297    slug__iregex: Option<Vec<String>>,
2298    slug__isw: Option<Vec<String>>,
2299    slug__n: Option<Vec<String>>,
2300    slug__nic: Option<Vec<String>>,
2301    slug__nie: Option<Vec<String>>,
2302    slug__niew: Option<Vec<String>>,
2303    slug__nisw: Option<Vec<String>>,
2304    slug__regex: Option<Vec<String>>,
2305    start: Option<i32>,
2306    tag: Option<Vec<String>>,
2307    tag__n: Option<Vec<String>>,
2308    tag_id: Option<Vec<i32>>,
2309    tag_id__n: Option<Vec<i32>>,
2310    updated_by_request: Option<&str>,
2311) -> Result<crate::models::PaginatedContactGroupList, Error<TenancyContactGroupsListError>> {
2312    let local_var_configuration = configuration;
2313
2314    let local_var_client = &local_var_configuration.client;
2315
2316    let local_var_uri_str = format!(
2317        "{}/api/tenancy/contact-groups/",
2318        local_var_configuration.base_path
2319    );
2320    let mut local_var_req_builder =
2321        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2322
2323    if let Some(ref local_var_str) = ancestor {
2324        local_var_req_builder = match "multi" {
2325            "multi" => local_var_req_builder.query(
2326                &local_var_str
2327                    .into_iter()
2328                    .map(|p| ("ancestor".to_owned(), p.to_string()))
2329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2330            ),
2331            _ => local_var_req_builder.query(&[(
2332                "ancestor",
2333                &local_var_str
2334                    .into_iter()
2335                    .map(|p| p.to_string())
2336                    .collect::<Vec<String>>()
2337                    .join(",")
2338                    .to_string(),
2339            )]),
2340        };
2341    }
2342    if let Some(ref local_var_str) = ancestor__n {
2343        local_var_req_builder = match "multi" {
2344            "multi" => local_var_req_builder.query(
2345                &local_var_str
2346                    .into_iter()
2347                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
2348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2349            ),
2350            _ => local_var_req_builder.query(&[(
2351                "ancestor__n",
2352                &local_var_str
2353                    .into_iter()
2354                    .map(|p| p.to_string())
2355                    .collect::<Vec<String>>()
2356                    .join(",")
2357                    .to_string(),
2358            )]),
2359        };
2360    }
2361    if let Some(ref local_var_str) = ancestor_id {
2362        local_var_req_builder = match "multi" {
2363            "multi" => local_var_req_builder.query(
2364                &local_var_str
2365                    .into_iter()
2366                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
2367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2368            ),
2369            _ => local_var_req_builder.query(&[(
2370                "ancestor_id",
2371                &local_var_str
2372                    .into_iter()
2373                    .map(|p| p.to_string())
2374                    .collect::<Vec<String>>()
2375                    .join(",")
2376                    .to_string(),
2377            )]),
2378        };
2379    }
2380    if let Some(ref local_var_str) = ancestor_id__n {
2381        local_var_req_builder = match "multi" {
2382            "multi" => local_var_req_builder.query(
2383                &local_var_str
2384                    .into_iter()
2385                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
2386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2387            ),
2388            _ => local_var_req_builder.query(&[(
2389                "ancestor_id__n",
2390                &local_var_str
2391                    .into_iter()
2392                    .map(|p| p.to_string())
2393                    .collect::<Vec<String>>()
2394                    .join(",")
2395                    .to_string(),
2396            )]),
2397        };
2398    }
2399    if let Some(ref local_var_str) = contact_id {
2400        local_var_req_builder = match "multi" {
2401            "multi" => local_var_req_builder.query(
2402                &local_var_str
2403                    .into_iter()
2404                    .map(|p| ("contact_id".to_owned(), p.to_string()))
2405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2406            ),
2407            _ => local_var_req_builder.query(&[(
2408                "contact_id",
2409                &local_var_str
2410                    .into_iter()
2411                    .map(|p| p.to_string())
2412                    .collect::<Vec<String>>()
2413                    .join(",")
2414                    .to_string(),
2415            )]),
2416        };
2417    }
2418    if let Some(ref local_var_str) = contact_id__n {
2419        local_var_req_builder = match "multi" {
2420            "multi" => local_var_req_builder.query(
2421                &local_var_str
2422                    .into_iter()
2423                    .map(|p| ("contact_id__n".to_owned(), p.to_string()))
2424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2425            ),
2426            _ => local_var_req_builder.query(&[(
2427                "contact_id__n",
2428                &local_var_str
2429                    .into_iter()
2430                    .map(|p| p.to_string())
2431                    .collect::<Vec<String>>()
2432                    .join(",")
2433                    .to_string(),
2434            )]),
2435        };
2436    }
2437    if let Some(ref local_var_str) = created {
2438        local_var_req_builder = match "multi" {
2439            "multi" => local_var_req_builder.query(
2440                &local_var_str
2441                    .into_iter()
2442                    .map(|p| ("created".to_owned(), p.to_string()))
2443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2444            ),
2445            _ => local_var_req_builder.query(&[(
2446                "created",
2447                &local_var_str
2448                    .into_iter()
2449                    .map(|p| p.to_string())
2450                    .collect::<Vec<String>>()
2451                    .join(",")
2452                    .to_string(),
2453            )]),
2454        };
2455    }
2456    if let Some(ref local_var_str) = created__empty {
2457        local_var_req_builder = match "multi" {
2458            "multi" => local_var_req_builder.query(
2459                &local_var_str
2460                    .into_iter()
2461                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2463            ),
2464            _ => local_var_req_builder.query(&[(
2465                "created__empty",
2466                &local_var_str
2467                    .into_iter()
2468                    .map(|p| p.to_string())
2469                    .collect::<Vec<String>>()
2470                    .join(",")
2471                    .to_string(),
2472            )]),
2473        };
2474    }
2475    if let Some(ref local_var_str) = created__gt {
2476        local_var_req_builder = match "multi" {
2477            "multi" => local_var_req_builder.query(
2478                &local_var_str
2479                    .into_iter()
2480                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2482            ),
2483            _ => local_var_req_builder.query(&[(
2484                "created__gt",
2485                &local_var_str
2486                    .into_iter()
2487                    .map(|p| p.to_string())
2488                    .collect::<Vec<String>>()
2489                    .join(",")
2490                    .to_string(),
2491            )]),
2492        };
2493    }
2494    if let Some(ref local_var_str) = created__gte {
2495        local_var_req_builder = match "multi" {
2496            "multi" => local_var_req_builder.query(
2497                &local_var_str
2498                    .into_iter()
2499                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2501            ),
2502            _ => local_var_req_builder.query(&[(
2503                "created__gte",
2504                &local_var_str
2505                    .into_iter()
2506                    .map(|p| p.to_string())
2507                    .collect::<Vec<String>>()
2508                    .join(",")
2509                    .to_string(),
2510            )]),
2511        };
2512    }
2513    if let Some(ref local_var_str) = created__lt {
2514        local_var_req_builder = match "multi" {
2515            "multi" => local_var_req_builder.query(
2516                &local_var_str
2517                    .into_iter()
2518                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2520            ),
2521            _ => local_var_req_builder.query(&[(
2522                "created__lt",
2523                &local_var_str
2524                    .into_iter()
2525                    .map(|p| p.to_string())
2526                    .collect::<Vec<String>>()
2527                    .join(",")
2528                    .to_string(),
2529            )]),
2530        };
2531    }
2532    if let Some(ref local_var_str) = created__lte {
2533        local_var_req_builder = match "multi" {
2534            "multi" => local_var_req_builder.query(
2535                &local_var_str
2536                    .into_iter()
2537                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2539            ),
2540            _ => local_var_req_builder.query(&[(
2541                "created__lte",
2542                &local_var_str
2543                    .into_iter()
2544                    .map(|p| p.to_string())
2545                    .collect::<Vec<String>>()
2546                    .join(",")
2547                    .to_string(),
2548            )]),
2549        };
2550    }
2551    if let Some(ref local_var_str) = created__n {
2552        local_var_req_builder = match "multi" {
2553            "multi" => local_var_req_builder.query(
2554                &local_var_str
2555                    .into_iter()
2556                    .map(|p| ("created__n".to_owned(), p.to_string()))
2557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2558            ),
2559            _ => local_var_req_builder.query(&[(
2560                "created__n",
2561                &local_var_str
2562                    .into_iter()
2563                    .map(|p| p.to_string())
2564                    .collect::<Vec<String>>()
2565                    .join(",")
2566                    .to_string(),
2567            )]),
2568        };
2569    }
2570    if let Some(ref local_var_str) = created_by_request {
2571        local_var_req_builder =
2572            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2573    }
2574    if let Some(ref local_var_str) = description {
2575        local_var_req_builder = match "multi" {
2576            "multi" => local_var_req_builder.query(
2577                &local_var_str
2578                    .into_iter()
2579                    .map(|p| ("description".to_owned(), p.to_string()))
2580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2581            ),
2582            _ => local_var_req_builder.query(&[(
2583                "description",
2584                &local_var_str
2585                    .into_iter()
2586                    .map(|p| p.to_string())
2587                    .collect::<Vec<String>>()
2588                    .join(",")
2589                    .to_string(),
2590            )]),
2591        };
2592    }
2593    if let Some(ref local_var_str) = description__empty {
2594        local_var_req_builder =
2595            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2596    }
2597    if let Some(ref local_var_str) = description__ic {
2598        local_var_req_builder = match "multi" {
2599            "multi" => local_var_req_builder.query(
2600                &local_var_str
2601                    .into_iter()
2602                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2604            ),
2605            _ => local_var_req_builder.query(&[(
2606                "description__ic",
2607                &local_var_str
2608                    .into_iter()
2609                    .map(|p| p.to_string())
2610                    .collect::<Vec<String>>()
2611                    .join(",")
2612                    .to_string(),
2613            )]),
2614        };
2615    }
2616    if let Some(ref local_var_str) = description__ie {
2617        local_var_req_builder = match "multi" {
2618            "multi" => local_var_req_builder.query(
2619                &local_var_str
2620                    .into_iter()
2621                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2623            ),
2624            _ => local_var_req_builder.query(&[(
2625                "description__ie",
2626                &local_var_str
2627                    .into_iter()
2628                    .map(|p| p.to_string())
2629                    .collect::<Vec<String>>()
2630                    .join(",")
2631                    .to_string(),
2632            )]),
2633        };
2634    }
2635    if let Some(ref local_var_str) = description__iew {
2636        local_var_req_builder = match "multi" {
2637            "multi" => local_var_req_builder.query(
2638                &local_var_str
2639                    .into_iter()
2640                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2642            ),
2643            _ => local_var_req_builder.query(&[(
2644                "description__iew",
2645                &local_var_str
2646                    .into_iter()
2647                    .map(|p| p.to_string())
2648                    .collect::<Vec<String>>()
2649                    .join(",")
2650                    .to_string(),
2651            )]),
2652        };
2653    }
2654    if let Some(ref local_var_str) = description__iregex {
2655        local_var_req_builder = match "multi" {
2656            "multi" => local_var_req_builder.query(
2657                &local_var_str
2658                    .into_iter()
2659                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2661            ),
2662            _ => local_var_req_builder.query(&[(
2663                "description__iregex",
2664                &local_var_str
2665                    .into_iter()
2666                    .map(|p| p.to_string())
2667                    .collect::<Vec<String>>()
2668                    .join(",")
2669                    .to_string(),
2670            )]),
2671        };
2672    }
2673    if let Some(ref local_var_str) = description__isw {
2674        local_var_req_builder = match "multi" {
2675            "multi" => local_var_req_builder.query(
2676                &local_var_str
2677                    .into_iter()
2678                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2680            ),
2681            _ => local_var_req_builder.query(&[(
2682                "description__isw",
2683                &local_var_str
2684                    .into_iter()
2685                    .map(|p| p.to_string())
2686                    .collect::<Vec<String>>()
2687                    .join(",")
2688                    .to_string(),
2689            )]),
2690        };
2691    }
2692    if let Some(ref local_var_str) = description__n {
2693        local_var_req_builder = match "multi" {
2694            "multi" => local_var_req_builder.query(
2695                &local_var_str
2696                    .into_iter()
2697                    .map(|p| ("description__n".to_owned(), p.to_string()))
2698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2699            ),
2700            _ => local_var_req_builder.query(&[(
2701                "description__n",
2702                &local_var_str
2703                    .into_iter()
2704                    .map(|p| p.to_string())
2705                    .collect::<Vec<String>>()
2706                    .join(",")
2707                    .to_string(),
2708            )]),
2709        };
2710    }
2711    if let Some(ref local_var_str) = description__nic {
2712        local_var_req_builder = match "multi" {
2713            "multi" => local_var_req_builder.query(
2714                &local_var_str
2715                    .into_iter()
2716                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2718            ),
2719            _ => local_var_req_builder.query(&[(
2720                "description__nic",
2721                &local_var_str
2722                    .into_iter()
2723                    .map(|p| p.to_string())
2724                    .collect::<Vec<String>>()
2725                    .join(",")
2726                    .to_string(),
2727            )]),
2728        };
2729    }
2730    if let Some(ref local_var_str) = description__nie {
2731        local_var_req_builder = match "multi" {
2732            "multi" => local_var_req_builder.query(
2733                &local_var_str
2734                    .into_iter()
2735                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2737            ),
2738            _ => local_var_req_builder.query(&[(
2739                "description__nie",
2740                &local_var_str
2741                    .into_iter()
2742                    .map(|p| p.to_string())
2743                    .collect::<Vec<String>>()
2744                    .join(",")
2745                    .to_string(),
2746            )]),
2747        };
2748    }
2749    if let Some(ref local_var_str) = description__niew {
2750        local_var_req_builder = match "multi" {
2751            "multi" => local_var_req_builder.query(
2752                &local_var_str
2753                    .into_iter()
2754                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2756            ),
2757            _ => local_var_req_builder.query(&[(
2758                "description__niew",
2759                &local_var_str
2760                    .into_iter()
2761                    .map(|p| p.to_string())
2762                    .collect::<Vec<String>>()
2763                    .join(",")
2764                    .to_string(),
2765            )]),
2766        };
2767    }
2768    if let Some(ref local_var_str) = description__nisw {
2769        local_var_req_builder = match "multi" {
2770            "multi" => local_var_req_builder.query(
2771                &local_var_str
2772                    .into_iter()
2773                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2775            ),
2776            _ => local_var_req_builder.query(&[(
2777                "description__nisw",
2778                &local_var_str
2779                    .into_iter()
2780                    .map(|p| p.to_string())
2781                    .collect::<Vec<String>>()
2782                    .join(",")
2783                    .to_string(),
2784            )]),
2785        };
2786    }
2787    if let Some(ref local_var_str) = description__regex {
2788        local_var_req_builder = match "multi" {
2789            "multi" => local_var_req_builder.query(
2790                &local_var_str
2791                    .into_iter()
2792                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2794            ),
2795            _ => local_var_req_builder.query(&[(
2796                "description__regex",
2797                &local_var_str
2798                    .into_iter()
2799                    .map(|p| p.to_string())
2800                    .collect::<Vec<String>>()
2801                    .join(",")
2802                    .to_string(),
2803            )]),
2804        };
2805    }
2806    if let Some(ref local_var_str) = id {
2807        local_var_req_builder = match "multi" {
2808            "multi" => local_var_req_builder.query(
2809                &local_var_str
2810                    .into_iter()
2811                    .map(|p| ("id".to_owned(), p.to_string()))
2812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2813            ),
2814            _ => local_var_req_builder.query(&[(
2815                "id",
2816                &local_var_str
2817                    .into_iter()
2818                    .map(|p| p.to_string())
2819                    .collect::<Vec<String>>()
2820                    .join(",")
2821                    .to_string(),
2822            )]),
2823        };
2824    }
2825    if let Some(ref local_var_str) = id__empty {
2826        local_var_req_builder =
2827            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2828    }
2829    if let Some(ref local_var_str) = id__gt {
2830        local_var_req_builder = match "multi" {
2831            "multi" => local_var_req_builder.query(
2832                &local_var_str
2833                    .into_iter()
2834                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2836            ),
2837            _ => local_var_req_builder.query(&[(
2838                "id__gt",
2839                &local_var_str
2840                    .into_iter()
2841                    .map(|p| p.to_string())
2842                    .collect::<Vec<String>>()
2843                    .join(",")
2844                    .to_string(),
2845            )]),
2846        };
2847    }
2848    if let Some(ref local_var_str) = id__gte {
2849        local_var_req_builder = match "multi" {
2850            "multi" => local_var_req_builder.query(
2851                &local_var_str
2852                    .into_iter()
2853                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2855            ),
2856            _ => local_var_req_builder.query(&[(
2857                "id__gte",
2858                &local_var_str
2859                    .into_iter()
2860                    .map(|p| p.to_string())
2861                    .collect::<Vec<String>>()
2862                    .join(",")
2863                    .to_string(),
2864            )]),
2865        };
2866    }
2867    if let Some(ref local_var_str) = id__lt {
2868        local_var_req_builder = match "multi" {
2869            "multi" => local_var_req_builder.query(
2870                &local_var_str
2871                    .into_iter()
2872                    .map(|p| ("id__lt".to_owned(), p.to_string()))
2873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2874            ),
2875            _ => local_var_req_builder.query(&[(
2876                "id__lt",
2877                &local_var_str
2878                    .into_iter()
2879                    .map(|p| p.to_string())
2880                    .collect::<Vec<String>>()
2881                    .join(",")
2882                    .to_string(),
2883            )]),
2884        };
2885    }
2886    if let Some(ref local_var_str) = id__lte {
2887        local_var_req_builder = match "multi" {
2888            "multi" => local_var_req_builder.query(
2889                &local_var_str
2890                    .into_iter()
2891                    .map(|p| ("id__lte".to_owned(), p.to_string()))
2892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2893            ),
2894            _ => local_var_req_builder.query(&[(
2895                "id__lte",
2896                &local_var_str
2897                    .into_iter()
2898                    .map(|p| p.to_string())
2899                    .collect::<Vec<String>>()
2900                    .join(",")
2901                    .to_string(),
2902            )]),
2903        };
2904    }
2905    if let Some(ref local_var_str) = id__n {
2906        local_var_req_builder = match "multi" {
2907            "multi" => local_var_req_builder.query(
2908                &local_var_str
2909                    .into_iter()
2910                    .map(|p| ("id__n".to_owned(), p.to_string()))
2911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2912            ),
2913            _ => local_var_req_builder.query(&[(
2914                "id__n",
2915                &local_var_str
2916                    .into_iter()
2917                    .map(|p| p.to_string())
2918                    .collect::<Vec<String>>()
2919                    .join(",")
2920                    .to_string(),
2921            )]),
2922        };
2923    }
2924    if let Some(ref local_var_str) = last_updated {
2925        local_var_req_builder = match "multi" {
2926            "multi" => local_var_req_builder.query(
2927                &local_var_str
2928                    .into_iter()
2929                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2931            ),
2932            _ => local_var_req_builder.query(&[(
2933                "last_updated",
2934                &local_var_str
2935                    .into_iter()
2936                    .map(|p| p.to_string())
2937                    .collect::<Vec<String>>()
2938                    .join(",")
2939                    .to_string(),
2940            )]),
2941        };
2942    }
2943    if let Some(ref local_var_str) = last_updated__empty {
2944        local_var_req_builder = match "multi" {
2945            "multi" => local_var_req_builder.query(
2946                &local_var_str
2947                    .into_iter()
2948                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
2949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2950            ),
2951            _ => local_var_req_builder.query(&[(
2952                "last_updated__empty",
2953                &local_var_str
2954                    .into_iter()
2955                    .map(|p| p.to_string())
2956                    .collect::<Vec<String>>()
2957                    .join(",")
2958                    .to_string(),
2959            )]),
2960        };
2961    }
2962    if let Some(ref local_var_str) = last_updated__gt {
2963        local_var_req_builder = match "multi" {
2964            "multi" => local_var_req_builder.query(
2965                &local_var_str
2966                    .into_iter()
2967                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
2968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2969            ),
2970            _ => local_var_req_builder.query(&[(
2971                "last_updated__gt",
2972                &local_var_str
2973                    .into_iter()
2974                    .map(|p| p.to_string())
2975                    .collect::<Vec<String>>()
2976                    .join(",")
2977                    .to_string(),
2978            )]),
2979        };
2980    }
2981    if let Some(ref local_var_str) = last_updated__gte {
2982        local_var_req_builder = match "multi" {
2983            "multi" => local_var_req_builder.query(
2984                &local_var_str
2985                    .into_iter()
2986                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
2987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2988            ),
2989            _ => local_var_req_builder.query(&[(
2990                "last_updated__gte",
2991                &local_var_str
2992                    .into_iter()
2993                    .map(|p| p.to_string())
2994                    .collect::<Vec<String>>()
2995                    .join(",")
2996                    .to_string(),
2997            )]),
2998        };
2999    }
3000    if let Some(ref local_var_str) = last_updated__lt {
3001        local_var_req_builder = match "multi" {
3002            "multi" => local_var_req_builder.query(
3003                &local_var_str
3004                    .into_iter()
3005                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3007            ),
3008            _ => local_var_req_builder.query(&[(
3009                "last_updated__lt",
3010                &local_var_str
3011                    .into_iter()
3012                    .map(|p| p.to_string())
3013                    .collect::<Vec<String>>()
3014                    .join(",")
3015                    .to_string(),
3016            )]),
3017        };
3018    }
3019    if let Some(ref local_var_str) = last_updated__lte {
3020        local_var_req_builder = match "multi" {
3021            "multi" => local_var_req_builder.query(
3022                &local_var_str
3023                    .into_iter()
3024                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3026            ),
3027            _ => local_var_req_builder.query(&[(
3028                "last_updated__lte",
3029                &local_var_str
3030                    .into_iter()
3031                    .map(|p| p.to_string())
3032                    .collect::<Vec<String>>()
3033                    .join(",")
3034                    .to_string(),
3035            )]),
3036        };
3037    }
3038    if let Some(ref local_var_str) = last_updated__n {
3039        local_var_req_builder = match "multi" {
3040            "multi" => local_var_req_builder.query(
3041                &local_var_str
3042                    .into_iter()
3043                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3045            ),
3046            _ => local_var_req_builder.query(&[(
3047                "last_updated__n",
3048                &local_var_str
3049                    .into_iter()
3050                    .map(|p| p.to_string())
3051                    .collect::<Vec<String>>()
3052                    .join(",")
3053                    .to_string(),
3054            )]),
3055        };
3056    }
3057    if let Some(ref local_var_str) = limit {
3058        local_var_req_builder =
3059            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3060    }
3061    if let Some(ref local_var_str) = modified_by_request {
3062        local_var_req_builder =
3063            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3064    }
3065    if let Some(ref local_var_str) = name {
3066        local_var_req_builder = match "multi" {
3067            "multi" => local_var_req_builder.query(
3068                &local_var_str
3069                    .into_iter()
3070                    .map(|p| ("name".to_owned(), p.to_string()))
3071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3072            ),
3073            _ => local_var_req_builder.query(&[(
3074                "name",
3075                &local_var_str
3076                    .into_iter()
3077                    .map(|p| p.to_string())
3078                    .collect::<Vec<String>>()
3079                    .join(",")
3080                    .to_string(),
3081            )]),
3082        };
3083    }
3084    if let Some(ref local_var_str) = name__empty {
3085        local_var_req_builder =
3086            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3087    }
3088    if let Some(ref local_var_str) = name__ic {
3089        local_var_req_builder = match "multi" {
3090            "multi" => local_var_req_builder.query(
3091                &local_var_str
3092                    .into_iter()
3093                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3095            ),
3096            _ => local_var_req_builder.query(&[(
3097                "name__ic",
3098                &local_var_str
3099                    .into_iter()
3100                    .map(|p| p.to_string())
3101                    .collect::<Vec<String>>()
3102                    .join(",")
3103                    .to_string(),
3104            )]),
3105        };
3106    }
3107    if let Some(ref local_var_str) = name__ie {
3108        local_var_req_builder = match "multi" {
3109            "multi" => local_var_req_builder.query(
3110                &local_var_str
3111                    .into_iter()
3112                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3114            ),
3115            _ => local_var_req_builder.query(&[(
3116                "name__ie",
3117                &local_var_str
3118                    .into_iter()
3119                    .map(|p| p.to_string())
3120                    .collect::<Vec<String>>()
3121                    .join(",")
3122                    .to_string(),
3123            )]),
3124        };
3125    }
3126    if let Some(ref local_var_str) = name__iew {
3127        local_var_req_builder = match "multi" {
3128            "multi" => local_var_req_builder.query(
3129                &local_var_str
3130                    .into_iter()
3131                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3133            ),
3134            _ => local_var_req_builder.query(&[(
3135                "name__iew",
3136                &local_var_str
3137                    .into_iter()
3138                    .map(|p| p.to_string())
3139                    .collect::<Vec<String>>()
3140                    .join(",")
3141                    .to_string(),
3142            )]),
3143        };
3144    }
3145    if let Some(ref local_var_str) = name__iregex {
3146        local_var_req_builder = match "multi" {
3147            "multi" => local_var_req_builder.query(
3148                &local_var_str
3149                    .into_iter()
3150                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3152            ),
3153            _ => local_var_req_builder.query(&[(
3154                "name__iregex",
3155                &local_var_str
3156                    .into_iter()
3157                    .map(|p| p.to_string())
3158                    .collect::<Vec<String>>()
3159                    .join(",")
3160                    .to_string(),
3161            )]),
3162        };
3163    }
3164    if let Some(ref local_var_str) = name__isw {
3165        local_var_req_builder = match "multi" {
3166            "multi" => local_var_req_builder.query(
3167                &local_var_str
3168                    .into_iter()
3169                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3171            ),
3172            _ => local_var_req_builder.query(&[(
3173                "name__isw",
3174                &local_var_str
3175                    .into_iter()
3176                    .map(|p| p.to_string())
3177                    .collect::<Vec<String>>()
3178                    .join(",")
3179                    .to_string(),
3180            )]),
3181        };
3182    }
3183    if let Some(ref local_var_str) = name__n {
3184        local_var_req_builder = match "multi" {
3185            "multi" => local_var_req_builder.query(
3186                &local_var_str
3187                    .into_iter()
3188                    .map(|p| ("name__n".to_owned(), p.to_string()))
3189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3190            ),
3191            _ => local_var_req_builder.query(&[(
3192                "name__n",
3193                &local_var_str
3194                    .into_iter()
3195                    .map(|p| p.to_string())
3196                    .collect::<Vec<String>>()
3197                    .join(",")
3198                    .to_string(),
3199            )]),
3200        };
3201    }
3202    if let Some(ref local_var_str) = name__nic {
3203        local_var_req_builder = match "multi" {
3204            "multi" => local_var_req_builder.query(
3205                &local_var_str
3206                    .into_iter()
3207                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3209            ),
3210            _ => local_var_req_builder.query(&[(
3211                "name__nic",
3212                &local_var_str
3213                    .into_iter()
3214                    .map(|p| p.to_string())
3215                    .collect::<Vec<String>>()
3216                    .join(",")
3217                    .to_string(),
3218            )]),
3219        };
3220    }
3221    if let Some(ref local_var_str) = name__nie {
3222        local_var_req_builder = match "multi" {
3223            "multi" => local_var_req_builder.query(
3224                &local_var_str
3225                    .into_iter()
3226                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3228            ),
3229            _ => local_var_req_builder.query(&[(
3230                "name__nie",
3231                &local_var_str
3232                    .into_iter()
3233                    .map(|p| p.to_string())
3234                    .collect::<Vec<String>>()
3235                    .join(",")
3236                    .to_string(),
3237            )]),
3238        };
3239    }
3240    if let Some(ref local_var_str) = name__niew {
3241        local_var_req_builder = match "multi" {
3242            "multi" => local_var_req_builder.query(
3243                &local_var_str
3244                    .into_iter()
3245                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3247            ),
3248            _ => local_var_req_builder.query(&[(
3249                "name__niew",
3250                &local_var_str
3251                    .into_iter()
3252                    .map(|p| p.to_string())
3253                    .collect::<Vec<String>>()
3254                    .join(",")
3255                    .to_string(),
3256            )]),
3257        };
3258    }
3259    if let Some(ref local_var_str) = name__nisw {
3260        local_var_req_builder = match "multi" {
3261            "multi" => local_var_req_builder.query(
3262                &local_var_str
3263                    .into_iter()
3264                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3266            ),
3267            _ => local_var_req_builder.query(&[(
3268                "name__nisw",
3269                &local_var_str
3270                    .into_iter()
3271                    .map(|p| p.to_string())
3272                    .collect::<Vec<String>>()
3273                    .join(",")
3274                    .to_string(),
3275            )]),
3276        };
3277    }
3278    if let Some(ref local_var_str) = name__regex {
3279        local_var_req_builder = match "multi" {
3280            "multi" => local_var_req_builder.query(
3281                &local_var_str
3282                    .into_iter()
3283                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3285            ),
3286            _ => local_var_req_builder.query(&[(
3287                "name__regex",
3288                &local_var_str
3289                    .into_iter()
3290                    .map(|p| p.to_string())
3291                    .collect::<Vec<String>>()
3292                    .join(",")
3293                    .to_string(),
3294            )]),
3295        };
3296    }
3297    if let Some(ref local_var_str) = offset {
3298        local_var_req_builder =
3299            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3300    }
3301    if let Some(ref local_var_str) = ordering {
3302        local_var_req_builder =
3303            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3304    }
3305    if let Some(ref local_var_str) = owner {
3306        local_var_req_builder = match "multi" {
3307            "multi" => local_var_req_builder.query(
3308                &local_var_str
3309                    .into_iter()
3310                    .map(|p| ("owner".to_owned(), p.to_string()))
3311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3312            ),
3313            _ => local_var_req_builder.query(&[(
3314                "owner",
3315                &local_var_str
3316                    .into_iter()
3317                    .map(|p| p.to_string())
3318                    .collect::<Vec<String>>()
3319                    .join(",")
3320                    .to_string(),
3321            )]),
3322        };
3323    }
3324    if let Some(ref local_var_str) = owner__n {
3325        local_var_req_builder = match "multi" {
3326            "multi" => local_var_req_builder.query(
3327                &local_var_str
3328                    .into_iter()
3329                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3331            ),
3332            _ => local_var_req_builder.query(&[(
3333                "owner__n",
3334                &local_var_str
3335                    .into_iter()
3336                    .map(|p| p.to_string())
3337                    .collect::<Vec<String>>()
3338                    .join(",")
3339                    .to_string(),
3340            )]),
3341        };
3342    }
3343    if let Some(ref local_var_str) = owner_group {
3344        local_var_req_builder = match "multi" {
3345            "multi" => local_var_req_builder.query(
3346                &local_var_str
3347                    .into_iter()
3348                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3350            ),
3351            _ => local_var_req_builder.query(&[(
3352                "owner_group",
3353                &local_var_str
3354                    .into_iter()
3355                    .map(|p| p.to_string())
3356                    .collect::<Vec<String>>()
3357                    .join(",")
3358                    .to_string(),
3359            )]),
3360        };
3361    }
3362    if let Some(ref local_var_str) = owner_group__n {
3363        local_var_req_builder = match "multi" {
3364            "multi" => local_var_req_builder.query(
3365                &local_var_str
3366                    .into_iter()
3367                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3369            ),
3370            _ => local_var_req_builder.query(&[(
3371                "owner_group__n",
3372                &local_var_str
3373                    .into_iter()
3374                    .map(|p| p.to_string())
3375                    .collect::<Vec<String>>()
3376                    .join(",")
3377                    .to_string(),
3378            )]),
3379        };
3380    }
3381    if let Some(ref local_var_str) = owner_group_id {
3382        local_var_req_builder = match "multi" {
3383            "multi" => local_var_req_builder.query(
3384                &local_var_str
3385                    .into_iter()
3386                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3388            ),
3389            _ => local_var_req_builder.query(&[(
3390                "owner_group_id",
3391                &local_var_str
3392                    .into_iter()
3393                    .map(|p| p.to_string())
3394                    .collect::<Vec<String>>()
3395                    .join(",")
3396                    .to_string(),
3397            )]),
3398        };
3399    }
3400    if let Some(ref local_var_str) = owner_group_id__n {
3401        local_var_req_builder = match "multi" {
3402            "multi" => local_var_req_builder.query(
3403                &local_var_str
3404                    .into_iter()
3405                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3407            ),
3408            _ => local_var_req_builder.query(&[(
3409                "owner_group_id__n",
3410                &local_var_str
3411                    .into_iter()
3412                    .map(|p| p.to_string())
3413                    .collect::<Vec<String>>()
3414                    .join(",")
3415                    .to_string(),
3416            )]),
3417        };
3418    }
3419    if let Some(ref local_var_str) = owner_id {
3420        local_var_req_builder = match "multi" {
3421            "multi" => local_var_req_builder.query(
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3426            ),
3427            _ => local_var_req_builder.query(&[(
3428                "owner_id",
3429                &local_var_str
3430                    .into_iter()
3431                    .map(|p| p.to_string())
3432                    .collect::<Vec<String>>()
3433                    .join(",")
3434                    .to_string(),
3435            )]),
3436        };
3437    }
3438    if let Some(ref local_var_str) = owner_id__n {
3439        local_var_req_builder = match "multi" {
3440            "multi" => local_var_req_builder.query(
3441                &local_var_str
3442                    .into_iter()
3443                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3445            ),
3446            _ => local_var_req_builder.query(&[(
3447                "owner_id__n",
3448                &local_var_str
3449                    .into_iter()
3450                    .map(|p| p.to_string())
3451                    .collect::<Vec<String>>()
3452                    .join(",")
3453                    .to_string(),
3454            )]),
3455        };
3456    }
3457    if let Some(ref local_var_str) = parent {
3458        local_var_req_builder = match "multi" {
3459            "multi" => local_var_req_builder.query(
3460                &local_var_str
3461                    .into_iter()
3462                    .map(|p| ("parent".to_owned(), p.to_string()))
3463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3464            ),
3465            _ => local_var_req_builder.query(&[(
3466                "parent",
3467                &local_var_str
3468                    .into_iter()
3469                    .map(|p| p.to_string())
3470                    .collect::<Vec<String>>()
3471                    .join(",")
3472                    .to_string(),
3473            )]),
3474        };
3475    }
3476    if let Some(ref local_var_str) = parent__n {
3477        local_var_req_builder = match "multi" {
3478            "multi" => local_var_req_builder.query(
3479                &local_var_str
3480                    .into_iter()
3481                    .map(|p| ("parent__n".to_owned(), p.to_string()))
3482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3483            ),
3484            _ => local_var_req_builder.query(&[(
3485                "parent__n",
3486                &local_var_str
3487                    .into_iter()
3488                    .map(|p| p.to_string())
3489                    .collect::<Vec<String>>()
3490                    .join(",")
3491                    .to_string(),
3492            )]),
3493        };
3494    }
3495    if let Some(ref local_var_str) = parent_id {
3496        local_var_req_builder = match "multi" {
3497            "multi" => local_var_req_builder.query(
3498                &local_var_str
3499                    .into_iter()
3500                    .map(|p| ("parent_id".to_owned(), p.to_string()))
3501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3502            ),
3503            _ => local_var_req_builder.query(&[(
3504                "parent_id",
3505                &local_var_str
3506                    .into_iter()
3507                    .map(|p| p.to_string())
3508                    .collect::<Vec<String>>()
3509                    .join(",")
3510                    .to_string(),
3511            )]),
3512        };
3513    }
3514    if let Some(ref local_var_str) = parent_id__n {
3515        local_var_req_builder = match "multi" {
3516            "multi" => local_var_req_builder.query(
3517                &local_var_str
3518                    .into_iter()
3519                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
3520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3521            ),
3522            _ => local_var_req_builder.query(&[(
3523                "parent_id__n",
3524                &local_var_str
3525                    .into_iter()
3526                    .map(|p| p.to_string())
3527                    .collect::<Vec<String>>()
3528                    .join(",")
3529                    .to_string(),
3530            )]),
3531        };
3532    }
3533    if let Some(ref local_var_str) = q {
3534        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3535    }
3536    if let Some(ref local_var_str) = slug {
3537        local_var_req_builder = match "multi" {
3538            "multi" => local_var_req_builder.query(
3539                &local_var_str
3540                    .into_iter()
3541                    .map(|p| ("slug".to_owned(), p.to_string()))
3542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3543            ),
3544            _ => local_var_req_builder.query(&[(
3545                "slug",
3546                &local_var_str
3547                    .into_iter()
3548                    .map(|p| p.to_string())
3549                    .collect::<Vec<String>>()
3550                    .join(",")
3551                    .to_string(),
3552            )]),
3553        };
3554    }
3555    if let Some(ref local_var_str) = slug__empty {
3556        local_var_req_builder =
3557            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3558    }
3559    if let Some(ref local_var_str) = slug__ic {
3560        local_var_req_builder = match "multi" {
3561            "multi" => local_var_req_builder.query(
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3566            ),
3567            _ => local_var_req_builder.query(&[(
3568                "slug__ic",
3569                &local_var_str
3570                    .into_iter()
3571                    .map(|p| p.to_string())
3572                    .collect::<Vec<String>>()
3573                    .join(",")
3574                    .to_string(),
3575            )]),
3576        };
3577    }
3578    if let Some(ref local_var_str) = slug__ie {
3579        local_var_req_builder = match "multi" {
3580            "multi" => local_var_req_builder.query(
3581                &local_var_str
3582                    .into_iter()
3583                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3585            ),
3586            _ => local_var_req_builder.query(&[(
3587                "slug__ie",
3588                &local_var_str
3589                    .into_iter()
3590                    .map(|p| p.to_string())
3591                    .collect::<Vec<String>>()
3592                    .join(",")
3593                    .to_string(),
3594            )]),
3595        };
3596    }
3597    if let Some(ref local_var_str) = slug__iew {
3598        local_var_req_builder = match "multi" {
3599            "multi" => local_var_req_builder.query(
3600                &local_var_str
3601                    .into_iter()
3602                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3604            ),
3605            _ => local_var_req_builder.query(&[(
3606                "slug__iew",
3607                &local_var_str
3608                    .into_iter()
3609                    .map(|p| p.to_string())
3610                    .collect::<Vec<String>>()
3611                    .join(",")
3612                    .to_string(),
3613            )]),
3614        };
3615    }
3616    if let Some(ref local_var_str) = slug__iregex {
3617        local_var_req_builder = match "multi" {
3618            "multi" => local_var_req_builder.query(
3619                &local_var_str
3620                    .into_iter()
3621                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3623            ),
3624            _ => local_var_req_builder.query(&[(
3625                "slug__iregex",
3626                &local_var_str
3627                    .into_iter()
3628                    .map(|p| p.to_string())
3629                    .collect::<Vec<String>>()
3630                    .join(",")
3631                    .to_string(),
3632            )]),
3633        };
3634    }
3635    if let Some(ref local_var_str) = slug__isw {
3636        local_var_req_builder = match "multi" {
3637            "multi" => local_var_req_builder.query(
3638                &local_var_str
3639                    .into_iter()
3640                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3642            ),
3643            _ => local_var_req_builder.query(&[(
3644                "slug__isw",
3645                &local_var_str
3646                    .into_iter()
3647                    .map(|p| p.to_string())
3648                    .collect::<Vec<String>>()
3649                    .join(",")
3650                    .to_string(),
3651            )]),
3652        };
3653    }
3654    if let Some(ref local_var_str) = slug__n {
3655        local_var_req_builder = match "multi" {
3656            "multi" => local_var_req_builder.query(
3657                &local_var_str
3658                    .into_iter()
3659                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3661            ),
3662            _ => local_var_req_builder.query(&[(
3663                "slug__n",
3664                &local_var_str
3665                    .into_iter()
3666                    .map(|p| p.to_string())
3667                    .collect::<Vec<String>>()
3668                    .join(",")
3669                    .to_string(),
3670            )]),
3671        };
3672    }
3673    if let Some(ref local_var_str) = slug__nic {
3674        local_var_req_builder = match "multi" {
3675            "multi" => local_var_req_builder.query(
3676                &local_var_str
3677                    .into_iter()
3678                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3680            ),
3681            _ => local_var_req_builder.query(&[(
3682                "slug__nic",
3683                &local_var_str
3684                    .into_iter()
3685                    .map(|p| p.to_string())
3686                    .collect::<Vec<String>>()
3687                    .join(",")
3688                    .to_string(),
3689            )]),
3690        };
3691    }
3692    if let Some(ref local_var_str) = slug__nie {
3693        local_var_req_builder = match "multi" {
3694            "multi" => local_var_req_builder.query(
3695                &local_var_str
3696                    .into_iter()
3697                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3699            ),
3700            _ => local_var_req_builder.query(&[(
3701                "slug__nie",
3702                &local_var_str
3703                    .into_iter()
3704                    .map(|p| p.to_string())
3705                    .collect::<Vec<String>>()
3706                    .join(",")
3707                    .to_string(),
3708            )]),
3709        };
3710    }
3711    if let Some(ref local_var_str) = slug__niew {
3712        local_var_req_builder = match "multi" {
3713            "multi" => local_var_req_builder.query(
3714                &local_var_str
3715                    .into_iter()
3716                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3718            ),
3719            _ => local_var_req_builder.query(&[(
3720                "slug__niew",
3721                &local_var_str
3722                    .into_iter()
3723                    .map(|p| p.to_string())
3724                    .collect::<Vec<String>>()
3725                    .join(",")
3726                    .to_string(),
3727            )]),
3728        };
3729    }
3730    if let Some(ref local_var_str) = slug__nisw {
3731        local_var_req_builder = match "multi" {
3732            "multi" => local_var_req_builder.query(
3733                &local_var_str
3734                    .into_iter()
3735                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3737            ),
3738            _ => local_var_req_builder.query(&[(
3739                "slug__nisw",
3740                &local_var_str
3741                    .into_iter()
3742                    .map(|p| p.to_string())
3743                    .collect::<Vec<String>>()
3744                    .join(",")
3745                    .to_string(),
3746            )]),
3747        };
3748    }
3749    if let Some(ref local_var_str) = slug__regex {
3750        local_var_req_builder = match "multi" {
3751            "multi" => local_var_req_builder.query(
3752                &local_var_str
3753                    .into_iter()
3754                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3756            ),
3757            _ => local_var_req_builder.query(&[(
3758                "slug__regex",
3759                &local_var_str
3760                    .into_iter()
3761                    .map(|p| p.to_string())
3762                    .collect::<Vec<String>>()
3763                    .join(",")
3764                    .to_string(),
3765            )]),
3766        };
3767    }
3768    if let Some(ref local_var_str) = start {
3769        local_var_req_builder =
3770            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
3771    }
3772    if let Some(ref local_var_str) = tag {
3773        local_var_req_builder = match "multi" {
3774            "multi" => local_var_req_builder.query(
3775                &local_var_str
3776                    .into_iter()
3777                    .map(|p| ("tag".to_owned(), p.to_string()))
3778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3779            ),
3780            _ => local_var_req_builder.query(&[(
3781                "tag",
3782                &local_var_str
3783                    .into_iter()
3784                    .map(|p| p.to_string())
3785                    .collect::<Vec<String>>()
3786                    .join(",")
3787                    .to_string(),
3788            )]),
3789        };
3790    }
3791    if let Some(ref local_var_str) = tag__n {
3792        local_var_req_builder = match "multi" {
3793            "multi" => local_var_req_builder.query(
3794                &local_var_str
3795                    .into_iter()
3796                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3798            ),
3799            _ => local_var_req_builder.query(&[(
3800                "tag__n",
3801                &local_var_str
3802                    .into_iter()
3803                    .map(|p| p.to_string())
3804                    .collect::<Vec<String>>()
3805                    .join(",")
3806                    .to_string(),
3807            )]),
3808        };
3809    }
3810    if let Some(ref local_var_str) = tag_id {
3811        local_var_req_builder = match "multi" {
3812            "multi" => local_var_req_builder.query(
3813                &local_var_str
3814                    .into_iter()
3815                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3817            ),
3818            _ => local_var_req_builder.query(&[(
3819                "tag_id",
3820                &local_var_str
3821                    .into_iter()
3822                    .map(|p| p.to_string())
3823                    .collect::<Vec<String>>()
3824                    .join(",")
3825                    .to_string(),
3826            )]),
3827        };
3828    }
3829    if let Some(ref local_var_str) = tag_id__n {
3830        local_var_req_builder = match "multi" {
3831            "multi" => local_var_req_builder.query(
3832                &local_var_str
3833                    .into_iter()
3834                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3836            ),
3837            _ => local_var_req_builder.query(&[(
3838                "tag_id__n",
3839                &local_var_str
3840                    .into_iter()
3841                    .map(|p| p.to_string())
3842                    .collect::<Vec<String>>()
3843                    .join(",")
3844                    .to_string(),
3845            )]),
3846        };
3847    }
3848    if let Some(ref local_var_str) = updated_by_request {
3849        local_var_req_builder =
3850            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
3851    }
3852    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3853        local_var_req_builder =
3854            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3855    }
3856    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3857        let local_var_key = local_var_apikey.key.clone();
3858        let local_var_value = match local_var_apikey.prefix {
3859            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3860            None => local_var_key,
3861        };
3862        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3863    };
3864
3865    let local_var_req = local_var_req_builder.build()?;
3866    let local_var_resp = local_var_client.execute(local_var_req).await?;
3867
3868    let local_var_status = local_var_resp.status();
3869    let local_var_content = local_var_resp.text().await?;
3870
3871    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3872        serde_json::from_str(&local_var_content).map_err(Error::from)
3873    } else {
3874        let local_var_entity: Option<TenancyContactGroupsListError> =
3875            serde_json::from_str(&local_var_content).ok();
3876        let local_var_error = ResponseContent {
3877            status: local_var_status,
3878            content: local_var_content,
3879            entity: local_var_entity,
3880        };
3881        Err(Error::ResponseError(local_var_error))
3882    }
3883}
3884
3885/// Patch a contact group object.
3886pub async fn tenancy_contact_groups_partial_update(
3887    configuration: &configuration::Configuration,
3888    id: i32,
3889    patched_writable_contact_group_request: Option<
3890        crate::models::PatchedWritableContactGroupRequest,
3891    >,
3892) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsPartialUpdateError>> {
3893    let local_var_configuration = configuration;
3894
3895    let local_var_client = &local_var_configuration.client;
3896
3897    let local_var_uri_str = format!(
3898        "{}/api/tenancy/contact-groups/{id}/",
3899        local_var_configuration.base_path,
3900        id = id
3901    );
3902    let mut local_var_req_builder =
3903        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3904
3905    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3906        local_var_req_builder =
3907            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3908    }
3909    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3910        let local_var_key = local_var_apikey.key.clone();
3911        let local_var_value = match local_var_apikey.prefix {
3912            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3913            None => local_var_key,
3914        };
3915        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3916    };
3917    local_var_req_builder = local_var_req_builder.json(&patched_writable_contact_group_request);
3918
3919    let local_var_req = local_var_req_builder.build()?;
3920    let local_var_resp = local_var_client.execute(local_var_req).await?;
3921
3922    let local_var_status = local_var_resp.status();
3923    let local_var_content = local_var_resp.text().await?;
3924
3925    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3926        serde_json::from_str(&local_var_content).map_err(Error::from)
3927    } else {
3928        let local_var_entity: Option<TenancyContactGroupsPartialUpdateError> =
3929            serde_json::from_str(&local_var_content).ok();
3930        let local_var_error = ResponseContent {
3931            status: local_var_status,
3932            content: local_var_content,
3933            entity: local_var_entity,
3934        };
3935        Err(Error::ResponseError(local_var_error))
3936    }
3937}
3938
3939/// Get a contact group object.
3940pub async fn tenancy_contact_groups_retrieve(
3941    configuration: &configuration::Configuration,
3942    id: i32,
3943) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsRetrieveError>> {
3944    let local_var_configuration = configuration;
3945
3946    let local_var_client = &local_var_configuration.client;
3947
3948    let local_var_uri_str = format!(
3949        "{}/api/tenancy/contact-groups/{id}/",
3950        local_var_configuration.base_path,
3951        id = id
3952    );
3953    let mut local_var_req_builder =
3954        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3955
3956    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3957        local_var_req_builder =
3958            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3959    }
3960    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3961        let local_var_key = local_var_apikey.key.clone();
3962        let local_var_value = match local_var_apikey.prefix {
3963            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3964            None => local_var_key,
3965        };
3966        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3967    };
3968
3969    let local_var_req = local_var_req_builder.build()?;
3970    let local_var_resp = local_var_client.execute(local_var_req).await?;
3971
3972    let local_var_status = local_var_resp.status();
3973    let local_var_content = local_var_resp.text().await?;
3974
3975    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3976        serde_json::from_str(&local_var_content).map_err(Error::from)
3977    } else {
3978        let local_var_entity: Option<TenancyContactGroupsRetrieveError> =
3979            serde_json::from_str(&local_var_content).ok();
3980        let local_var_error = ResponseContent {
3981            status: local_var_status,
3982            content: local_var_content,
3983            entity: local_var_entity,
3984        };
3985        Err(Error::ResponseError(local_var_error))
3986    }
3987}
3988
3989/// Put a contact group object.
3990pub async fn tenancy_contact_groups_update(
3991    configuration: &configuration::Configuration,
3992    id: i32,
3993    writable_contact_group_request: crate::models::WritableContactGroupRequest,
3994) -> Result<crate::models::ContactGroup, Error<TenancyContactGroupsUpdateError>> {
3995    let local_var_configuration = configuration;
3996
3997    let local_var_client = &local_var_configuration.client;
3998
3999    let local_var_uri_str = format!(
4000        "{}/api/tenancy/contact-groups/{id}/",
4001        local_var_configuration.base_path,
4002        id = id
4003    );
4004    let mut local_var_req_builder =
4005        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4006
4007    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4008        local_var_req_builder =
4009            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4010    }
4011    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4012        let local_var_key = local_var_apikey.key.clone();
4013        let local_var_value = match local_var_apikey.prefix {
4014            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4015            None => local_var_key,
4016        };
4017        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4018    };
4019    local_var_req_builder = local_var_req_builder.json(&writable_contact_group_request);
4020
4021    let local_var_req = local_var_req_builder.build()?;
4022    let local_var_resp = local_var_client.execute(local_var_req).await?;
4023
4024    let local_var_status = local_var_resp.status();
4025    let local_var_content = local_var_resp.text().await?;
4026
4027    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4028        serde_json::from_str(&local_var_content).map_err(Error::from)
4029    } else {
4030        let local_var_entity: Option<TenancyContactGroupsUpdateError> =
4031            serde_json::from_str(&local_var_content).ok();
4032        let local_var_error = ResponseContent {
4033            status: local_var_status,
4034            content: local_var_content,
4035            entity: local_var_entity,
4036        };
4037        Err(Error::ResponseError(local_var_error))
4038    }
4039}
4040
4041/// Delete a list of contact role objects.
4042pub async fn tenancy_contact_roles_bulk_destroy(
4043    configuration: &configuration::Configuration,
4044    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4045) -> Result<(), Error<TenancyContactRolesBulkDestroyError>> {
4046    let local_var_configuration = configuration;
4047
4048    let local_var_client = &local_var_configuration.client;
4049
4050    let local_var_uri_str = format!(
4051        "{}/api/tenancy/contact-roles/",
4052        local_var_configuration.base_path
4053    );
4054    let mut local_var_req_builder =
4055        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4056
4057    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4058        local_var_req_builder =
4059            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4060    }
4061    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4062        let local_var_key = local_var_apikey.key.clone();
4063        let local_var_value = match local_var_apikey.prefix {
4064            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4065            None => local_var_key,
4066        };
4067        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4068    };
4069    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4070
4071    let local_var_req = local_var_req_builder.build()?;
4072    let local_var_resp = local_var_client.execute(local_var_req).await?;
4073
4074    let local_var_status = local_var_resp.status();
4075    let local_var_content = local_var_resp.text().await?;
4076
4077    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4078        Ok(())
4079    } else {
4080        let local_var_entity: Option<TenancyContactRolesBulkDestroyError> =
4081            serde_json::from_str(&local_var_content).ok();
4082        let local_var_error = ResponseContent {
4083            status: local_var_status,
4084            content: local_var_content,
4085            entity: local_var_entity,
4086        };
4087        Err(Error::ResponseError(local_var_error))
4088    }
4089}
4090
4091/// Patch a list of contact role objects.
4092pub async fn tenancy_contact_roles_bulk_partial_update(
4093    configuration: &configuration::Configuration,
4094    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4095) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkPartialUpdateError>> {
4096    let local_var_configuration = configuration;
4097
4098    let local_var_client = &local_var_configuration.client;
4099
4100    let local_var_uri_str = format!(
4101        "{}/api/tenancy/contact-roles/",
4102        local_var_configuration.base_path
4103    );
4104    let mut local_var_req_builder =
4105        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4106
4107    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4108        local_var_req_builder =
4109            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4110    }
4111    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4112        let local_var_key = local_var_apikey.key.clone();
4113        let local_var_value = match local_var_apikey.prefix {
4114            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4115            None => local_var_key,
4116        };
4117        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4118    };
4119    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4120
4121    let local_var_req = local_var_req_builder.build()?;
4122    let local_var_resp = local_var_client.execute(local_var_req).await?;
4123
4124    let local_var_status = local_var_resp.status();
4125    let local_var_content = local_var_resp.text().await?;
4126
4127    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4128        serde_json::from_str(&local_var_content).map_err(Error::from)
4129    } else {
4130        let local_var_entity: Option<TenancyContactRolesBulkPartialUpdateError> =
4131            serde_json::from_str(&local_var_content).ok();
4132        let local_var_error = ResponseContent {
4133            status: local_var_status,
4134            content: local_var_content,
4135            entity: local_var_entity,
4136        };
4137        Err(Error::ResponseError(local_var_error))
4138    }
4139}
4140
4141/// Put a list of contact role objects.
4142pub async fn tenancy_contact_roles_bulk_update(
4143    configuration: &configuration::Configuration,
4144    contact_role_request: Vec<crate::models::ContactRoleRequest>,
4145) -> Result<Vec<crate::models::ContactRole>, Error<TenancyContactRolesBulkUpdateError>> {
4146    let local_var_configuration = configuration;
4147
4148    let local_var_client = &local_var_configuration.client;
4149
4150    let local_var_uri_str = format!(
4151        "{}/api/tenancy/contact-roles/",
4152        local_var_configuration.base_path
4153    );
4154    let mut local_var_req_builder =
4155        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4156
4157    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4158        local_var_req_builder =
4159            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4160    }
4161    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4162        let local_var_key = local_var_apikey.key.clone();
4163        let local_var_value = match local_var_apikey.prefix {
4164            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4165            None => local_var_key,
4166        };
4167        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4168    };
4169    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
4170
4171    let local_var_req = local_var_req_builder.build()?;
4172    let local_var_resp = local_var_client.execute(local_var_req).await?;
4173
4174    let local_var_status = local_var_resp.status();
4175    let local_var_content = local_var_resp.text().await?;
4176
4177    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4178        serde_json::from_str(&local_var_content).map_err(Error::from)
4179    } else {
4180        let local_var_entity: Option<TenancyContactRolesBulkUpdateError> =
4181            serde_json::from_str(&local_var_content).ok();
4182        let local_var_error = ResponseContent {
4183            status: local_var_status,
4184            content: local_var_content,
4185            entity: local_var_entity,
4186        };
4187        Err(Error::ResponseError(local_var_error))
4188    }
4189}
4190
4191/// Post a list of contact role objects.
4192pub async fn tenancy_contact_roles_create(
4193    configuration: &configuration::Configuration,
4194    tenancy_contact_roles_create_request: crate::models::TenancyContactRolesCreateRequest,
4195) -> Result<crate::models::ContactRole, Error<TenancyContactRolesCreateError>> {
4196    let local_var_configuration = configuration;
4197
4198    let local_var_client = &local_var_configuration.client;
4199
4200    let local_var_uri_str = format!(
4201        "{}/api/tenancy/contact-roles/",
4202        local_var_configuration.base_path
4203    );
4204    let mut local_var_req_builder =
4205        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4206
4207    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4208        local_var_req_builder =
4209            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4210    }
4211    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4212        let local_var_key = local_var_apikey.key.clone();
4213        let local_var_value = match local_var_apikey.prefix {
4214            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4215            None => local_var_key,
4216        };
4217        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4218    };
4219    local_var_req_builder = local_var_req_builder.json(&tenancy_contact_roles_create_request);
4220
4221    let local_var_req = local_var_req_builder.build()?;
4222    let local_var_resp = local_var_client.execute(local_var_req).await?;
4223
4224    let local_var_status = local_var_resp.status();
4225    let local_var_content = local_var_resp.text().await?;
4226
4227    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4228        serde_json::from_str(&local_var_content).map_err(Error::from)
4229    } else {
4230        let local_var_entity: Option<TenancyContactRolesCreateError> =
4231            serde_json::from_str(&local_var_content).ok();
4232        let local_var_error = ResponseContent {
4233            status: local_var_status,
4234            content: local_var_content,
4235            entity: local_var_entity,
4236        };
4237        Err(Error::ResponseError(local_var_error))
4238    }
4239}
4240
4241/// Delete a contact role object.
4242pub async fn tenancy_contact_roles_destroy(
4243    configuration: &configuration::Configuration,
4244    id: i32,
4245) -> Result<(), Error<TenancyContactRolesDestroyError>> {
4246    let local_var_configuration = configuration;
4247
4248    let local_var_client = &local_var_configuration.client;
4249
4250    let local_var_uri_str = format!(
4251        "{}/api/tenancy/contact-roles/{id}/",
4252        local_var_configuration.base_path,
4253        id = id
4254    );
4255    let mut local_var_req_builder =
4256        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4257
4258    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4259        local_var_req_builder =
4260            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4261    }
4262    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4263        let local_var_key = local_var_apikey.key.clone();
4264        let local_var_value = match local_var_apikey.prefix {
4265            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4266            None => local_var_key,
4267        };
4268        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4269    };
4270
4271    let local_var_req = local_var_req_builder.build()?;
4272    let local_var_resp = local_var_client.execute(local_var_req).await?;
4273
4274    let local_var_status = local_var_resp.status();
4275    let local_var_content = local_var_resp.text().await?;
4276
4277    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4278        Ok(())
4279    } else {
4280        let local_var_entity: Option<TenancyContactRolesDestroyError> =
4281            serde_json::from_str(&local_var_content).ok();
4282        let local_var_error = ResponseContent {
4283            status: local_var_status,
4284            content: local_var_content,
4285            entity: local_var_entity,
4286        };
4287        Err(Error::ResponseError(local_var_error))
4288    }
4289}
4290
4291/// Get a list of contact role objects.
4292pub async fn tenancy_contact_roles_list(
4293    configuration: &configuration::Configuration,
4294    created: Option<Vec<String>>,
4295    created__empty: Option<Vec<String>>,
4296    created__gt: Option<Vec<String>>,
4297    created__gte: Option<Vec<String>>,
4298    created__lt: Option<Vec<String>>,
4299    created__lte: Option<Vec<String>>,
4300    created__n: Option<Vec<String>>,
4301    created_by_request: Option<&str>,
4302    description: Option<Vec<String>>,
4303    description__empty: Option<bool>,
4304    description__ic: Option<Vec<String>>,
4305    description__ie: Option<Vec<String>>,
4306    description__iew: Option<Vec<String>>,
4307    description__iregex: Option<Vec<String>>,
4308    description__isw: Option<Vec<String>>,
4309    description__n: Option<Vec<String>>,
4310    description__nic: Option<Vec<String>>,
4311    description__nie: Option<Vec<String>>,
4312    description__niew: Option<Vec<String>>,
4313    description__nisw: Option<Vec<String>>,
4314    description__regex: Option<Vec<String>>,
4315    id: Option<Vec<i32>>,
4316    id__empty: Option<bool>,
4317    id__gt: Option<Vec<i32>>,
4318    id__gte: Option<Vec<i32>>,
4319    id__lt: Option<Vec<i32>>,
4320    id__lte: Option<Vec<i32>>,
4321    id__n: Option<Vec<i32>>,
4322    last_updated: Option<Vec<String>>,
4323    last_updated__empty: Option<Vec<String>>,
4324    last_updated__gt: Option<Vec<String>>,
4325    last_updated__gte: Option<Vec<String>>,
4326    last_updated__lt: Option<Vec<String>>,
4327    last_updated__lte: Option<Vec<String>>,
4328    last_updated__n: Option<Vec<String>>,
4329    limit: Option<i32>,
4330    modified_by_request: Option<&str>,
4331    name: Option<Vec<String>>,
4332    name__empty: Option<bool>,
4333    name__ic: Option<Vec<String>>,
4334    name__ie: Option<Vec<String>>,
4335    name__iew: Option<Vec<String>>,
4336    name__iregex: Option<Vec<String>>,
4337    name__isw: Option<Vec<String>>,
4338    name__n: Option<Vec<String>>,
4339    name__nic: Option<Vec<String>>,
4340    name__nie: Option<Vec<String>>,
4341    name__niew: Option<Vec<String>>,
4342    name__nisw: Option<Vec<String>>,
4343    name__regex: Option<Vec<String>>,
4344    offset: Option<i32>,
4345    ordering: Option<&str>,
4346    owner: Option<Vec<String>>,
4347    owner__n: Option<Vec<String>>,
4348    owner_group: Option<Vec<String>>,
4349    owner_group__n: Option<Vec<String>>,
4350    owner_group_id: Option<Vec<i32>>,
4351    owner_group_id__n: Option<Vec<i32>>,
4352    owner_id: Option<Vec<i32>>,
4353    owner_id__n: Option<Vec<i32>>,
4354    q: Option<&str>,
4355    slug: Option<Vec<String>>,
4356    slug__empty: Option<bool>,
4357    slug__ic: Option<Vec<String>>,
4358    slug__ie: Option<Vec<String>>,
4359    slug__iew: Option<Vec<String>>,
4360    slug__iregex: Option<Vec<String>>,
4361    slug__isw: Option<Vec<String>>,
4362    slug__n: Option<Vec<String>>,
4363    slug__nic: Option<Vec<String>>,
4364    slug__nie: Option<Vec<String>>,
4365    slug__niew: Option<Vec<String>>,
4366    slug__nisw: Option<Vec<String>>,
4367    slug__regex: Option<Vec<String>>,
4368    start: Option<i32>,
4369    tag: Option<Vec<String>>,
4370    tag__n: Option<Vec<String>>,
4371    tag_id: Option<Vec<i32>>,
4372    tag_id__n: Option<Vec<i32>>,
4373    updated_by_request: Option<&str>,
4374) -> Result<crate::models::PaginatedContactRoleList, Error<TenancyContactRolesListError>> {
4375    let local_var_configuration = configuration;
4376
4377    let local_var_client = &local_var_configuration.client;
4378
4379    let local_var_uri_str = format!(
4380        "{}/api/tenancy/contact-roles/",
4381        local_var_configuration.base_path
4382    );
4383    let mut local_var_req_builder =
4384        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4385
4386    if let Some(ref local_var_str) = created {
4387        local_var_req_builder = match "multi" {
4388            "multi" => local_var_req_builder.query(
4389                &local_var_str
4390                    .into_iter()
4391                    .map(|p| ("created".to_owned(), p.to_string()))
4392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4393            ),
4394            _ => local_var_req_builder.query(&[(
4395                "created",
4396                &local_var_str
4397                    .into_iter()
4398                    .map(|p| p.to_string())
4399                    .collect::<Vec<String>>()
4400                    .join(",")
4401                    .to_string(),
4402            )]),
4403        };
4404    }
4405    if let Some(ref local_var_str) = created__empty {
4406        local_var_req_builder = match "multi" {
4407            "multi" => local_var_req_builder.query(
4408                &local_var_str
4409                    .into_iter()
4410                    .map(|p| ("created__empty".to_owned(), p.to_string()))
4411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4412            ),
4413            _ => local_var_req_builder.query(&[(
4414                "created__empty",
4415                &local_var_str
4416                    .into_iter()
4417                    .map(|p| p.to_string())
4418                    .collect::<Vec<String>>()
4419                    .join(",")
4420                    .to_string(),
4421            )]),
4422        };
4423    }
4424    if let Some(ref local_var_str) = created__gt {
4425        local_var_req_builder = match "multi" {
4426            "multi" => local_var_req_builder.query(
4427                &local_var_str
4428                    .into_iter()
4429                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4431            ),
4432            _ => local_var_req_builder.query(&[(
4433                "created__gt",
4434                &local_var_str
4435                    .into_iter()
4436                    .map(|p| p.to_string())
4437                    .collect::<Vec<String>>()
4438                    .join(",")
4439                    .to_string(),
4440            )]),
4441        };
4442    }
4443    if let Some(ref local_var_str) = created__gte {
4444        local_var_req_builder = match "multi" {
4445            "multi" => local_var_req_builder.query(
4446                &local_var_str
4447                    .into_iter()
4448                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4450            ),
4451            _ => local_var_req_builder.query(&[(
4452                "created__gte",
4453                &local_var_str
4454                    .into_iter()
4455                    .map(|p| p.to_string())
4456                    .collect::<Vec<String>>()
4457                    .join(",")
4458                    .to_string(),
4459            )]),
4460        };
4461    }
4462    if let Some(ref local_var_str) = created__lt {
4463        local_var_req_builder = match "multi" {
4464            "multi" => local_var_req_builder.query(
4465                &local_var_str
4466                    .into_iter()
4467                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4469            ),
4470            _ => local_var_req_builder.query(&[(
4471                "created__lt",
4472                &local_var_str
4473                    .into_iter()
4474                    .map(|p| p.to_string())
4475                    .collect::<Vec<String>>()
4476                    .join(",")
4477                    .to_string(),
4478            )]),
4479        };
4480    }
4481    if let Some(ref local_var_str) = created__lte {
4482        local_var_req_builder = match "multi" {
4483            "multi" => local_var_req_builder.query(
4484                &local_var_str
4485                    .into_iter()
4486                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4488            ),
4489            _ => local_var_req_builder.query(&[(
4490                "created__lte",
4491                &local_var_str
4492                    .into_iter()
4493                    .map(|p| p.to_string())
4494                    .collect::<Vec<String>>()
4495                    .join(",")
4496                    .to_string(),
4497            )]),
4498        };
4499    }
4500    if let Some(ref local_var_str) = created__n {
4501        local_var_req_builder = match "multi" {
4502            "multi" => local_var_req_builder.query(
4503                &local_var_str
4504                    .into_iter()
4505                    .map(|p| ("created__n".to_owned(), p.to_string()))
4506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4507            ),
4508            _ => local_var_req_builder.query(&[(
4509                "created__n",
4510                &local_var_str
4511                    .into_iter()
4512                    .map(|p| p.to_string())
4513                    .collect::<Vec<String>>()
4514                    .join(",")
4515                    .to_string(),
4516            )]),
4517        };
4518    }
4519    if let Some(ref local_var_str) = created_by_request {
4520        local_var_req_builder =
4521            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4522    }
4523    if let Some(ref local_var_str) = description {
4524        local_var_req_builder = match "multi" {
4525            "multi" => local_var_req_builder.query(
4526                &local_var_str
4527                    .into_iter()
4528                    .map(|p| ("description".to_owned(), p.to_string()))
4529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4530            ),
4531            _ => local_var_req_builder.query(&[(
4532                "description",
4533                &local_var_str
4534                    .into_iter()
4535                    .map(|p| p.to_string())
4536                    .collect::<Vec<String>>()
4537                    .join(",")
4538                    .to_string(),
4539            )]),
4540        };
4541    }
4542    if let Some(ref local_var_str) = description__empty {
4543        local_var_req_builder =
4544            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4545    }
4546    if let Some(ref local_var_str) = description__ic {
4547        local_var_req_builder = match "multi" {
4548            "multi" => local_var_req_builder.query(
4549                &local_var_str
4550                    .into_iter()
4551                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4553            ),
4554            _ => local_var_req_builder.query(&[(
4555                "description__ic",
4556                &local_var_str
4557                    .into_iter()
4558                    .map(|p| p.to_string())
4559                    .collect::<Vec<String>>()
4560                    .join(",")
4561                    .to_string(),
4562            )]),
4563        };
4564    }
4565    if let Some(ref local_var_str) = description__ie {
4566        local_var_req_builder = match "multi" {
4567            "multi" => local_var_req_builder.query(
4568                &local_var_str
4569                    .into_iter()
4570                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4572            ),
4573            _ => local_var_req_builder.query(&[(
4574                "description__ie",
4575                &local_var_str
4576                    .into_iter()
4577                    .map(|p| p.to_string())
4578                    .collect::<Vec<String>>()
4579                    .join(",")
4580                    .to_string(),
4581            )]),
4582        };
4583    }
4584    if let Some(ref local_var_str) = description__iew {
4585        local_var_req_builder = match "multi" {
4586            "multi" => local_var_req_builder.query(
4587                &local_var_str
4588                    .into_iter()
4589                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4591            ),
4592            _ => local_var_req_builder.query(&[(
4593                "description__iew",
4594                &local_var_str
4595                    .into_iter()
4596                    .map(|p| p.to_string())
4597                    .collect::<Vec<String>>()
4598                    .join(",")
4599                    .to_string(),
4600            )]),
4601        };
4602    }
4603    if let Some(ref local_var_str) = description__iregex {
4604        local_var_req_builder = match "multi" {
4605            "multi" => local_var_req_builder.query(
4606                &local_var_str
4607                    .into_iter()
4608                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4610            ),
4611            _ => local_var_req_builder.query(&[(
4612                "description__iregex",
4613                &local_var_str
4614                    .into_iter()
4615                    .map(|p| p.to_string())
4616                    .collect::<Vec<String>>()
4617                    .join(",")
4618                    .to_string(),
4619            )]),
4620        };
4621    }
4622    if let Some(ref local_var_str) = description__isw {
4623        local_var_req_builder = match "multi" {
4624            "multi" => local_var_req_builder.query(
4625                &local_var_str
4626                    .into_iter()
4627                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4629            ),
4630            _ => local_var_req_builder.query(&[(
4631                "description__isw",
4632                &local_var_str
4633                    .into_iter()
4634                    .map(|p| p.to_string())
4635                    .collect::<Vec<String>>()
4636                    .join(",")
4637                    .to_string(),
4638            )]),
4639        };
4640    }
4641    if let Some(ref local_var_str) = description__n {
4642        local_var_req_builder = match "multi" {
4643            "multi" => local_var_req_builder.query(
4644                &local_var_str
4645                    .into_iter()
4646                    .map(|p| ("description__n".to_owned(), p.to_string()))
4647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4648            ),
4649            _ => local_var_req_builder.query(&[(
4650                "description__n",
4651                &local_var_str
4652                    .into_iter()
4653                    .map(|p| p.to_string())
4654                    .collect::<Vec<String>>()
4655                    .join(",")
4656                    .to_string(),
4657            )]),
4658        };
4659    }
4660    if let Some(ref local_var_str) = description__nic {
4661        local_var_req_builder = match "multi" {
4662            "multi" => local_var_req_builder.query(
4663                &local_var_str
4664                    .into_iter()
4665                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4667            ),
4668            _ => local_var_req_builder.query(&[(
4669                "description__nic",
4670                &local_var_str
4671                    .into_iter()
4672                    .map(|p| p.to_string())
4673                    .collect::<Vec<String>>()
4674                    .join(",")
4675                    .to_string(),
4676            )]),
4677        };
4678    }
4679    if let Some(ref local_var_str) = description__nie {
4680        local_var_req_builder = match "multi" {
4681            "multi" => local_var_req_builder.query(
4682                &local_var_str
4683                    .into_iter()
4684                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4686            ),
4687            _ => local_var_req_builder.query(&[(
4688                "description__nie",
4689                &local_var_str
4690                    .into_iter()
4691                    .map(|p| p.to_string())
4692                    .collect::<Vec<String>>()
4693                    .join(",")
4694                    .to_string(),
4695            )]),
4696        };
4697    }
4698    if let Some(ref local_var_str) = description__niew {
4699        local_var_req_builder = match "multi" {
4700            "multi" => local_var_req_builder.query(
4701                &local_var_str
4702                    .into_iter()
4703                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4705            ),
4706            _ => local_var_req_builder.query(&[(
4707                "description__niew",
4708                &local_var_str
4709                    .into_iter()
4710                    .map(|p| p.to_string())
4711                    .collect::<Vec<String>>()
4712                    .join(",")
4713                    .to_string(),
4714            )]),
4715        };
4716    }
4717    if let Some(ref local_var_str) = description__nisw {
4718        local_var_req_builder = match "multi" {
4719            "multi" => local_var_req_builder.query(
4720                &local_var_str
4721                    .into_iter()
4722                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4724            ),
4725            _ => local_var_req_builder.query(&[(
4726                "description__nisw",
4727                &local_var_str
4728                    .into_iter()
4729                    .map(|p| p.to_string())
4730                    .collect::<Vec<String>>()
4731                    .join(",")
4732                    .to_string(),
4733            )]),
4734        };
4735    }
4736    if let Some(ref local_var_str) = description__regex {
4737        local_var_req_builder = match "multi" {
4738            "multi" => local_var_req_builder.query(
4739                &local_var_str
4740                    .into_iter()
4741                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4743            ),
4744            _ => local_var_req_builder.query(&[(
4745                "description__regex",
4746                &local_var_str
4747                    .into_iter()
4748                    .map(|p| p.to_string())
4749                    .collect::<Vec<String>>()
4750                    .join(",")
4751                    .to_string(),
4752            )]),
4753        };
4754    }
4755    if let Some(ref local_var_str) = id {
4756        local_var_req_builder = match "multi" {
4757            "multi" => local_var_req_builder.query(
4758                &local_var_str
4759                    .into_iter()
4760                    .map(|p| ("id".to_owned(), p.to_string()))
4761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4762            ),
4763            _ => local_var_req_builder.query(&[(
4764                "id",
4765                &local_var_str
4766                    .into_iter()
4767                    .map(|p| p.to_string())
4768                    .collect::<Vec<String>>()
4769                    .join(",")
4770                    .to_string(),
4771            )]),
4772        };
4773    }
4774    if let Some(ref local_var_str) = id__empty {
4775        local_var_req_builder =
4776            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4777    }
4778    if let Some(ref local_var_str) = id__gt {
4779        local_var_req_builder = match "multi" {
4780            "multi" => local_var_req_builder.query(
4781                &local_var_str
4782                    .into_iter()
4783                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4785            ),
4786            _ => local_var_req_builder.query(&[(
4787                "id__gt",
4788                &local_var_str
4789                    .into_iter()
4790                    .map(|p| p.to_string())
4791                    .collect::<Vec<String>>()
4792                    .join(",")
4793                    .to_string(),
4794            )]),
4795        };
4796    }
4797    if let Some(ref local_var_str) = id__gte {
4798        local_var_req_builder = match "multi" {
4799            "multi" => local_var_req_builder.query(
4800                &local_var_str
4801                    .into_iter()
4802                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4804            ),
4805            _ => local_var_req_builder.query(&[(
4806                "id__gte",
4807                &local_var_str
4808                    .into_iter()
4809                    .map(|p| p.to_string())
4810                    .collect::<Vec<String>>()
4811                    .join(",")
4812                    .to_string(),
4813            )]),
4814        };
4815    }
4816    if let Some(ref local_var_str) = id__lt {
4817        local_var_req_builder = match "multi" {
4818            "multi" => local_var_req_builder.query(
4819                &local_var_str
4820                    .into_iter()
4821                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4823            ),
4824            _ => local_var_req_builder.query(&[(
4825                "id__lt",
4826                &local_var_str
4827                    .into_iter()
4828                    .map(|p| p.to_string())
4829                    .collect::<Vec<String>>()
4830                    .join(",")
4831                    .to_string(),
4832            )]),
4833        };
4834    }
4835    if let Some(ref local_var_str) = id__lte {
4836        local_var_req_builder = match "multi" {
4837            "multi" => local_var_req_builder.query(
4838                &local_var_str
4839                    .into_iter()
4840                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4842            ),
4843            _ => local_var_req_builder.query(&[(
4844                "id__lte",
4845                &local_var_str
4846                    .into_iter()
4847                    .map(|p| p.to_string())
4848                    .collect::<Vec<String>>()
4849                    .join(",")
4850                    .to_string(),
4851            )]),
4852        };
4853    }
4854    if let Some(ref local_var_str) = id__n {
4855        local_var_req_builder = match "multi" {
4856            "multi" => local_var_req_builder.query(
4857                &local_var_str
4858                    .into_iter()
4859                    .map(|p| ("id__n".to_owned(), p.to_string()))
4860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4861            ),
4862            _ => local_var_req_builder.query(&[(
4863                "id__n",
4864                &local_var_str
4865                    .into_iter()
4866                    .map(|p| p.to_string())
4867                    .collect::<Vec<String>>()
4868                    .join(",")
4869                    .to_string(),
4870            )]),
4871        };
4872    }
4873    if let Some(ref local_var_str) = last_updated {
4874        local_var_req_builder = match "multi" {
4875            "multi" => local_var_req_builder.query(
4876                &local_var_str
4877                    .into_iter()
4878                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4880            ),
4881            _ => local_var_req_builder.query(&[(
4882                "last_updated",
4883                &local_var_str
4884                    .into_iter()
4885                    .map(|p| p.to_string())
4886                    .collect::<Vec<String>>()
4887                    .join(",")
4888                    .to_string(),
4889            )]),
4890        };
4891    }
4892    if let Some(ref local_var_str) = last_updated__empty {
4893        local_var_req_builder = match "multi" {
4894            "multi" => local_var_req_builder.query(
4895                &local_var_str
4896                    .into_iter()
4897                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4899            ),
4900            _ => local_var_req_builder.query(&[(
4901                "last_updated__empty",
4902                &local_var_str
4903                    .into_iter()
4904                    .map(|p| p.to_string())
4905                    .collect::<Vec<String>>()
4906                    .join(",")
4907                    .to_string(),
4908            )]),
4909        };
4910    }
4911    if let Some(ref local_var_str) = last_updated__gt {
4912        local_var_req_builder = match "multi" {
4913            "multi" => local_var_req_builder.query(
4914                &local_var_str
4915                    .into_iter()
4916                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4917                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4918            ),
4919            _ => local_var_req_builder.query(&[(
4920                "last_updated__gt",
4921                &local_var_str
4922                    .into_iter()
4923                    .map(|p| p.to_string())
4924                    .collect::<Vec<String>>()
4925                    .join(",")
4926                    .to_string(),
4927            )]),
4928        };
4929    }
4930    if let Some(ref local_var_str) = last_updated__gte {
4931        local_var_req_builder = match "multi" {
4932            "multi" => local_var_req_builder.query(
4933                &local_var_str
4934                    .into_iter()
4935                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4936                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4937            ),
4938            _ => local_var_req_builder.query(&[(
4939                "last_updated__gte",
4940                &local_var_str
4941                    .into_iter()
4942                    .map(|p| p.to_string())
4943                    .collect::<Vec<String>>()
4944                    .join(",")
4945                    .to_string(),
4946            )]),
4947        };
4948    }
4949    if let Some(ref local_var_str) = last_updated__lt {
4950        local_var_req_builder = match "multi" {
4951            "multi" => local_var_req_builder.query(
4952                &local_var_str
4953                    .into_iter()
4954                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4956            ),
4957            _ => local_var_req_builder.query(&[(
4958                "last_updated__lt",
4959                &local_var_str
4960                    .into_iter()
4961                    .map(|p| p.to_string())
4962                    .collect::<Vec<String>>()
4963                    .join(",")
4964                    .to_string(),
4965            )]),
4966        };
4967    }
4968    if let Some(ref local_var_str) = last_updated__lte {
4969        local_var_req_builder = match "multi" {
4970            "multi" => local_var_req_builder.query(
4971                &local_var_str
4972                    .into_iter()
4973                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4975            ),
4976            _ => local_var_req_builder.query(&[(
4977                "last_updated__lte",
4978                &local_var_str
4979                    .into_iter()
4980                    .map(|p| p.to_string())
4981                    .collect::<Vec<String>>()
4982                    .join(",")
4983                    .to_string(),
4984            )]),
4985        };
4986    }
4987    if let Some(ref local_var_str) = last_updated__n {
4988        local_var_req_builder = match "multi" {
4989            "multi" => local_var_req_builder.query(
4990                &local_var_str
4991                    .into_iter()
4992                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4994            ),
4995            _ => local_var_req_builder.query(&[(
4996                "last_updated__n",
4997                &local_var_str
4998                    .into_iter()
4999                    .map(|p| p.to_string())
5000                    .collect::<Vec<String>>()
5001                    .join(",")
5002                    .to_string(),
5003            )]),
5004        };
5005    }
5006    if let Some(ref local_var_str) = limit {
5007        local_var_req_builder =
5008            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5009    }
5010    if let Some(ref local_var_str) = modified_by_request {
5011        local_var_req_builder =
5012            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5013    }
5014    if let Some(ref local_var_str) = name {
5015        local_var_req_builder = match "multi" {
5016            "multi" => local_var_req_builder.query(
5017                &local_var_str
5018                    .into_iter()
5019                    .map(|p| ("name".to_owned(), p.to_string()))
5020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5021            ),
5022            _ => local_var_req_builder.query(&[(
5023                "name",
5024                &local_var_str
5025                    .into_iter()
5026                    .map(|p| p.to_string())
5027                    .collect::<Vec<String>>()
5028                    .join(",")
5029                    .to_string(),
5030            )]),
5031        };
5032    }
5033    if let Some(ref local_var_str) = name__empty {
5034        local_var_req_builder =
5035            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5036    }
5037    if let Some(ref local_var_str) = name__ic {
5038        local_var_req_builder = match "multi" {
5039            "multi" => local_var_req_builder.query(
5040                &local_var_str
5041                    .into_iter()
5042                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5044            ),
5045            _ => local_var_req_builder.query(&[(
5046                "name__ic",
5047                &local_var_str
5048                    .into_iter()
5049                    .map(|p| p.to_string())
5050                    .collect::<Vec<String>>()
5051                    .join(",")
5052                    .to_string(),
5053            )]),
5054        };
5055    }
5056    if let Some(ref local_var_str) = name__ie {
5057        local_var_req_builder = match "multi" {
5058            "multi" => local_var_req_builder.query(
5059                &local_var_str
5060                    .into_iter()
5061                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5063            ),
5064            _ => local_var_req_builder.query(&[(
5065                "name__ie",
5066                &local_var_str
5067                    .into_iter()
5068                    .map(|p| p.to_string())
5069                    .collect::<Vec<String>>()
5070                    .join(",")
5071                    .to_string(),
5072            )]),
5073        };
5074    }
5075    if let Some(ref local_var_str) = name__iew {
5076        local_var_req_builder = match "multi" {
5077            "multi" => local_var_req_builder.query(
5078                &local_var_str
5079                    .into_iter()
5080                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5082            ),
5083            _ => local_var_req_builder.query(&[(
5084                "name__iew",
5085                &local_var_str
5086                    .into_iter()
5087                    .map(|p| p.to_string())
5088                    .collect::<Vec<String>>()
5089                    .join(",")
5090                    .to_string(),
5091            )]),
5092        };
5093    }
5094    if let Some(ref local_var_str) = name__iregex {
5095        local_var_req_builder = match "multi" {
5096            "multi" => local_var_req_builder.query(
5097                &local_var_str
5098                    .into_iter()
5099                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5101            ),
5102            _ => local_var_req_builder.query(&[(
5103                "name__iregex",
5104                &local_var_str
5105                    .into_iter()
5106                    .map(|p| p.to_string())
5107                    .collect::<Vec<String>>()
5108                    .join(",")
5109                    .to_string(),
5110            )]),
5111        };
5112    }
5113    if let Some(ref local_var_str) = name__isw {
5114        local_var_req_builder = match "multi" {
5115            "multi" => local_var_req_builder.query(
5116                &local_var_str
5117                    .into_iter()
5118                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5120            ),
5121            _ => local_var_req_builder.query(&[(
5122                "name__isw",
5123                &local_var_str
5124                    .into_iter()
5125                    .map(|p| p.to_string())
5126                    .collect::<Vec<String>>()
5127                    .join(",")
5128                    .to_string(),
5129            )]),
5130        };
5131    }
5132    if let Some(ref local_var_str) = name__n {
5133        local_var_req_builder = match "multi" {
5134            "multi" => local_var_req_builder.query(
5135                &local_var_str
5136                    .into_iter()
5137                    .map(|p| ("name__n".to_owned(), p.to_string()))
5138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5139            ),
5140            _ => local_var_req_builder.query(&[(
5141                "name__n",
5142                &local_var_str
5143                    .into_iter()
5144                    .map(|p| p.to_string())
5145                    .collect::<Vec<String>>()
5146                    .join(",")
5147                    .to_string(),
5148            )]),
5149        };
5150    }
5151    if let Some(ref local_var_str) = name__nic {
5152        local_var_req_builder = match "multi" {
5153            "multi" => local_var_req_builder.query(
5154                &local_var_str
5155                    .into_iter()
5156                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5158            ),
5159            _ => local_var_req_builder.query(&[(
5160                "name__nic",
5161                &local_var_str
5162                    .into_iter()
5163                    .map(|p| p.to_string())
5164                    .collect::<Vec<String>>()
5165                    .join(",")
5166                    .to_string(),
5167            )]),
5168        };
5169    }
5170    if let Some(ref local_var_str) = name__nie {
5171        local_var_req_builder = match "multi" {
5172            "multi" => local_var_req_builder.query(
5173                &local_var_str
5174                    .into_iter()
5175                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5177            ),
5178            _ => local_var_req_builder.query(&[(
5179                "name__nie",
5180                &local_var_str
5181                    .into_iter()
5182                    .map(|p| p.to_string())
5183                    .collect::<Vec<String>>()
5184                    .join(",")
5185                    .to_string(),
5186            )]),
5187        };
5188    }
5189    if let Some(ref local_var_str) = name__niew {
5190        local_var_req_builder = match "multi" {
5191            "multi" => local_var_req_builder.query(
5192                &local_var_str
5193                    .into_iter()
5194                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5196            ),
5197            _ => local_var_req_builder.query(&[(
5198                "name__niew",
5199                &local_var_str
5200                    .into_iter()
5201                    .map(|p| p.to_string())
5202                    .collect::<Vec<String>>()
5203                    .join(",")
5204                    .to_string(),
5205            )]),
5206        };
5207    }
5208    if let Some(ref local_var_str) = name__nisw {
5209        local_var_req_builder = match "multi" {
5210            "multi" => local_var_req_builder.query(
5211                &local_var_str
5212                    .into_iter()
5213                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5215            ),
5216            _ => local_var_req_builder.query(&[(
5217                "name__nisw",
5218                &local_var_str
5219                    .into_iter()
5220                    .map(|p| p.to_string())
5221                    .collect::<Vec<String>>()
5222                    .join(",")
5223                    .to_string(),
5224            )]),
5225        };
5226    }
5227    if let Some(ref local_var_str) = name__regex {
5228        local_var_req_builder = match "multi" {
5229            "multi" => local_var_req_builder.query(
5230                &local_var_str
5231                    .into_iter()
5232                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5234            ),
5235            _ => local_var_req_builder.query(&[(
5236                "name__regex",
5237                &local_var_str
5238                    .into_iter()
5239                    .map(|p| p.to_string())
5240                    .collect::<Vec<String>>()
5241                    .join(",")
5242                    .to_string(),
5243            )]),
5244        };
5245    }
5246    if let Some(ref local_var_str) = offset {
5247        local_var_req_builder =
5248            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5249    }
5250    if let Some(ref local_var_str) = ordering {
5251        local_var_req_builder =
5252            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5253    }
5254    if let Some(ref local_var_str) = owner {
5255        local_var_req_builder = match "multi" {
5256            "multi" => local_var_req_builder.query(
5257                &local_var_str
5258                    .into_iter()
5259                    .map(|p| ("owner".to_owned(), p.to_string()))
5260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5261            ),
5262            _ => local_var_req_builder.query(&[(
5263                "owner",
5264                &local_var_str
5265                    .into_iter()
5266                    .map(|p| p.to_string())
5267                    .collect::<Vec<String>>()
5268                    .join(",")
5269                    .to_string(),
5270            )]),
5271        };
5272    }
5273    if let Some(ref local_var_str) = owner__n {
5274        local_var_req_builder = match "multi" {
5275            "multi" => local_var_req_builder.query(
5276                &local_var_str
5277                    .into_iter()
5278                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5280            ),
5281            _ => local_var_req_builder.query(&[(
5282                "owner__n",
5283                &local_var_str
5284                    .into_iter()
5285                    .map(|p| p.to_string())
5286                    .collect::<Vec<String>>()
5287                    .join(",")
5288                    .to_string(),
5289            )]),
5290        };
5291    }
5292    if let Some(ref local_var_str) = owner_group {
5293        local_var_req_builder = match "multi" {
5294            "multi" => local_var_req_builder.query(
5295                &local_var_str
5296                    .into_iter()
5297                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5299            ),
5300            _ => local_var_req_builder.query(&[(
5301                "owner_group",
5302                &local_var_str
5303                    .into_iter()
5304                    .map(|p| p.to_string())
5305                    .collect::<Vec<String>>()
5306                    .join(",")
5307                    .to_string(),
5308            )]),
5309        };
5310    }
5311    if let Some(ref local_var_str) = owner_group__n {
5312        local_var_req_builder = match "multi" {
5313            "multi" => local_var_req_builder.query(
5314                &local_var_str
5315                    .into_iter()
5316                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5318            ),
5319            _ => local_var_req_builder.query(&[(
5320                "owner_group__n",
5321                &local_var_str
5322                    .into_iter()
5323                    .map(|p| p.to_string())
5324                    .collect::<Vec<String>>()
5325                    .join(",")
5326                    .to_string(),
5327            )]),
5328        };
5329    }
5330    if let Some(ref local_var_str) = owner_group_id {
5331        local_var_req_builder = match "multi" {
5332            "multi" => local_var_req_builder.query(
5333                &local_var_str
5334                    .into_iter()
5335                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5337            ),
5338            _ => local_var_req_builder.query(&[(
5339                "owner_group_id",
5340                &local_var_str
5341                    .into_iter()
5342                    .map(|p| p.to_string())
5343                    .collect::<Vec<String>>()
5344                    .join(",")
5345                    .to_string(),
5346            )]),
5347        };
5348    }
5349    if let Some(ref local_var_str) = owner_group_id__n {
5350        local_var_req_builder = match "multi" {
5351            "multi" => local_var_req_builder.query(
5352                &local_var_str
5353                    .into_iter()
5354                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5356            ),
5357            _ => local_var_req_builder.query(&[(
5358                "owner_group_id__n",
5359                &local_var_str
5360                    .into_iter()
5361                    .map(|p| p.to_string())
5362                    .collect::<Vec<String>>()
5363                    .join(",")
5364                    .to_string(),
5365            )]),
5366        };
5367    }
5368    if let Some(ref local_var_str) = owner_id {
5369        local_var_req_builder = match "multi" {
5370            "multi" => local_var_req_builder.query(
5371                &local_var_str
5372                    .into_iter()
5373                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5374                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5375            ),
5376            _ => local_var_req_builder.query(&[(
5377                "owner_id",
5378                &local_var_str
5379                    .into_iter()
5380                    .map(|p| p.to_string())
5381                    .collect::<Vec<String>>()
5382                    .join(",")
5383                    .to_string(),
5384            )]),
5385        };
5386    }
5387    if let Some(ref local_var_str) = owner_id__n {
5388        local_var_req_builder = match "multi" {
5389            "multi" => local_var_req_builder.query(
5390                &local_var_str
5391                    .into_iter()
5392                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5394            ),
5395            _ => local_var_req_builder.query(&[(
5396                "owner_id__n",
5397                &local_var_str
5398                    .into_iter()
5399                    .map(|p| p.to_string())
5400                    .collect::<Vec<String>>()
5401                    .join(",")
5402                    .to_string(),
5403            )]),
5404        };
5405    }
5406    if let Some(ref local_var_str) = q {
5407        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5408    }
5409    if let Some(ref local_var_str) = slug {
5410        local_var_req_builder = match "multi" {
5411            "multi" => local_var_req_builder.query(
5412                &local_var_str
5413                    .into_iter()
5414                    .map(|p| ("slug".to_owned(), p.to_string()))
5415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5416            ),
5417            _ => local_var_req_builder.query(&[(
5418                "slug",
5419                &local_var_str
5420                    .into_iter()
5421                    .map(|p| p.to_string())
5422                    .collect::<Vec<String>>()
5423                    .join(",")
5424                    .to_string(),
5425            )]),
5426        };
5427    }
5428    if let Some(ref local_var_str) = slug__empty {
5429        local_var_req_builder =
5430            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
5431    }
5432    if let Some(ref local_var_str) = slug__ic {
5433        local_var_req_builder = match "multi" {
5434            "multi" => local_var_req_builder.query(
5435                &local_var_str
5436                    .into_iter()
5437                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
5438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5439            ),
5440            _ => local_var_req_builder.query(&[(
5441                "slug__ic",
5442                &local_var_str
5443                    .into_iter()
5444                    .map(|p| p.to_string())
5445                    .collect::<Vec<String>>()
5446                    .join(",")
5447                    .to_string(),
5448            )]),
5449        };
5450    }
5451    if let Some(ref local_var_str) = slug__ie {
5452        local_var_req_builder = match "multi" {
5453            "multi" => local_var_req_builder.query(
5454                &local_var_str
5455                    .into_iter()
5456                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
5457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5458            ),
5459            _ => local_var_req_builder.query(&[(
5460                "slug__ie",
5461                &local_var_str
5462                    .into_iter()
5463                    .map(|p| p.to_string())
5464                    .collect::<Vec<String>>()
5465                    .join(",")
5466                    .to_string(),
5467            )]),
5468        };
5469    }
5470    if let Some(ref local_var_str) = slug__iew {
5471        local_var_req_builder = match "multi" {
5472            "multi" => local_var_req_builder.query(
5473                &local_var_str
5474                    .into_iter()
5475                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
5476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5477            ),
5478            _ => local_var_req_builder.query(&[(
5479                "slug__iew",
5480                &local_var_str
5481                    .into_iter()
5482                    .map(|p| p.to_string())
5483                    .collect::<Vec<String>>()
5484                    .join(",")
5485                    .to_string(),
5486            )]),
5487        };
5488    }
5489    if let Some(ref local_var_str) = slug__iregex {
5490        local_var_req_builder = match "multi" {
5491            "multi" => local_var_req_builder.query(
5492                &local_var_str
5493                    .into_iter()
5494                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
5495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5496            ),
5497            _ => local_var_req_builder.query(&[(
5498                "slug__iregex",
5499                &local_var_str
5500                    .into_iter()
5501                    .map(|p| p.to_string())
5502                    .collect::<Vec<String>>()
5503                    .join(",")
5504                    .to_string(),
5505            )]),
5506        };
5507    }
5508    if let Some(ref local_var_str) = slug__isw {
5509        local_var_req_builder = match "multi" {
5510            "multi" => local_var_req_builder.query(
5511                &local_var_str
5512                    .into_iter()
5513                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
5514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5515            ),
5516            _ => local_var_req_builder.query(&[(
5517                "slug__isw",
5518                &local_var_str
5519                    .into_iter()
5520                    .map(|p| p.to_string())
5521                    .collect::<Vec<String>>()
5522                    .join(",")
5523                    .to_string(),
5524            )]),
5525        };
5526    }
5527    if let Some(ref local_var_str) = slug__n {
5528        local_var_req_builder = match "multi" {
5529            "multi" => local_var_req_builder.query(
5530                &local_var_str
5531                    .into_iter()
5532                    .map(|p| ("slug__n".to_owned(), p.to_string()))
5533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5534            ),
5535            _ => local_var_req_builder.query(&[(
5536                "slug__n",
5537                &local_var_str
5538                    .into_iter()
5539                    .map(|p| p.to_string())
5540                    .collect::<Vec<String>>()
5541                    .join(",")
5542                    .to_string(),
5543            )]),
5544        };
5545    }
5546    if let Some(ref local_var_str) = slug__nic {
5547        local_var_req_builder = match "multi" {
5548            "multi" => local_var_req_builder.query(
5549                &local_var_str
5550                    .into_iter()
5551                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
5552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5553            ),
5554            _ => local_var_req_builder.query(&[(
5555                "slug__nic",
5556                &local_var_str
5557                    .into_iter()
5558                    .map(|p| p.to_string())
5559                    .collect::<Vec<String>>()
5560                    .join(",")
5561                    .to_string(),
5562            )]),
5563        };
5564    }
5565    if let Some(ref local_var_str) = slug__nie {
5566        local_var_req_builder = match "multi" {
5567            "multi" => local_var_req_builder.query(
5568                &local_var_str
5569                    .into_iter()
5570                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
5571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5572            ),
5573            _ => local_var_req_builder.query(&[(
5574                "slug__nie",
5575                &local_var_str
5576                    .into_iter()
5577                    .map(|p| p.to_string())
5578                    .collect::<Vec<String>>()
5579                    .join(",")
5580                    .to_string(),
5581            )]),
5582        };
5583    }
5584    if let Some(ref local_var_str) = slug__niew {
5585        local_var_req_builder = match "multi" {
5586            "multi" => local_var_req_builder.query(
5587                &local_var_str
5588                    .into_iter()
5589                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
5590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5591            ),
5592            _ => local_var_req_builder.query(&[(
5593                "slug__niew",
5594                &local_var_str
5595                    .into_iter()
5596                    .map(|p| p.to_string())
5597                    .collect::<Vec<String>>()
5598                    .join(",")
5599                    .to_string(),
5600            )]),
5601        };
5602    }
5603    if let Some(ref local_var_str) = slug__nisw {
5604        local_var_req_builder = match "multi" {
5605            "multi" => local_var_req_builder.query(
5606                &local_var_str
5607                    .into_iter()
5608                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
5609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5610            ),
5611            _ => local_var_req_builder.query(&[(
5612                "slug__nisw",
5613                &local_var_str
5614                    .into_iter()
5615                    .map(|p| p.to_string())
5616                    .collect::<Vec<String>>()
5617                    .join(",")
5618                    .to_string(),
5619            )]),
5620        };
5621    }
5622    if let Some(ref local_var_str) = slug__regex {
5623        local_var_req_builder = match "multi" {
5624            "multi" => local_var_req_builder.query(
5625                &local_var_str
5626                    .into_iter()
5627                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
5628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5629            ),
5630            _ => local_var_req_builder.query(&[(
5631                "slug__regex",
5632                &local_var_str
5633                    .into_iter()
5634                    .map(|p| p.to_string())
5635                    .collect::<Vec<String>>()
5636                    .join(",")
5637                    .to_string(),
5638            )]),
5639        };
5640    }
5641    if let Some(ref local_var_str) = start {
5642        local_var_req_builder =
5643            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
5644    }
5645    if let Some(ref local_var_str) = tag {
5646        local_var_req_builder = match "multi" {
5647            "multi" => local_var_req_builder.query(
5648                &local_var_str
5649                    .into_iter()
5650                    .map(|p| ("tag".to_owned(), p.to_string()))
5651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5652            ),
5653            _ => local_var_req_builder.query(&[(
5654                "tag",
5655                &local_var_str
5656                    .into_iter()
5657                    .map(|p| p.to_string())
5658                    .collect::<Vec<String>>()
5659                    .join(",")
5660                    .to_string(),
5661            )]),
5662        };
5663    }
5664    if let Some(ref local_var_str) = tag__n {
5665        local_var_req_builder = match "multi" {
5666            "multi" => local_var_req_builder.query(
5667                &local_var_str
5668                    .into_iter()
5669                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5671            ),
5672            _ => local_var_req_builder.query(&[(
5673                "tag__n",
5674                &local_var_str
5675                    .into_iter()
5676                    .map(|p| p.to_string())
5677                    .collect::<Vec<String>>()
5678                    .join(",")
5679                    .to_string(),
5680            )]),
5681        };
5682    }
5683    if let Some(ref local_var_str) = tag_id {
5684        local_var_req_builder = match "multi" {
5685            "multi" => local_var_req_builder.query(
5686                &local_var_str
5687                    .into_iter()
5688                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5690            ),
5691            _ => local_var_req_builder.query(&[(
5692                "tag_id",
5693                &local_var_str
5694                    .into_iter()
5695                    .map(|p| p.to_string())
5696                    .collect::<Vec<String>>()
5697                    .join(",")
5698                    .to_string(),
5699            )]),
5700        };
5701    }
5702    if let Some(ref local_var_str) = tag_id__n {
5703        local_var_req_builder = match "multi" {
5704            "multi" => local_var_req_builder.query(
5705                &local_var_str
5706                    .into_iter()
5707                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5709            ),
5710            _ => local_var_req_builder.query(&[(
5711                "tag_id__n",
5712                &local_var_str
5713                    .into_iter()
5714                    .map(|p| p.to_string())
5715                    .collect::<Vec<String>>()
5716                    .join(",")
5717                    .to_string(),
5718            )]),
5719        };
5720    }
5721    if let Some(ref local_var_str) = updated_by_request {
5722        local_var_req_builder =
5723            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5724    }
5725    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5726        local_var_req_builder =
5727            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5728    }
5729    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5730        let local_var_key = local_var_apikey.key.clone();
5731        let local_var_value = match local_var_apikey.prefix {
5732            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5733            None => local_var_key,
5734        };
5735        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5736    };
5737
5738    let local_var_req = local_var_req_builder.build()?;
5739    let local_var_resp = local_var_client.execute(local_var_req).await?;
5740
5741    let local_var_status = local_var_resp.status();
5742    let local_var_content = local_var_resp.text().await?;
5743
5744    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5745        serde_json::from_str(&local_var_content).map_err(Error::from)
5746    } else {
5747        let local_var_entity: Option<TenancyContactRolesListError> =
5748            serde_json::from_str(&local_var_content).ok();
5749        let local_var_error = ResponseContent {
5750            status: local_var_status,
5751            content: local_var_content,
5752            entity: local_var_entity,
5753        };
5754        Err(Error::ResponseError(local_var_error))
5755    }
5756}
5757
5758/// Patch a contact role object.
5759pub async fn tenancy_contact_roles_partial_update(
5760    configuration: &configuration::Configuration,
5761    id: i32,
5762    patched_contact_role_request: Option<crate::models::PatchedContactRoleRequest>,
5763) -> Result<crate::models::ContactRole, Error<TenancyContactRolesPartialUpdateError>> {
5764    let local_var_configuration = configuration;
5765
5766    let local_var_client = &local_var_configuration.client;
5767
5768    let local_var_uri_str = format!(
5769        "{}/api/tenancy/contact-roles/{id}/",
5770        local_var_configuration.base_path,
5771        id = id
5772    );
5773    let mut local_var_req_builder =
5774        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5775
5776    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5777        local_var_req_builder =
5778            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5779    }
5780    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5781        let local_var_key = local_var_apikey.key.clone();
5782        let local_var_value = match local_var_apikey.prefix {
5783            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5784            None => local_var_key,
5785        };
5786        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5787    };
5788    local_var_req_builder = local_var_req_builder.json(&patched_contact_role_request);
5789
5790    let local_var_req = local_var_req_builder.build()?;
5791    let local_var_resp = local_var_client.execute(local_var_req).await?;
5792
5793    let local_var_status = local_var_resp.status();
5794    let local_var_content = local_var_resp.text().await?;
5795
5796    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5797        serde_json::from_str(&local_var_content).map_err(Error::from)
5798    } else {
5799        let local_var_entity: Option<TenancyContactRolesPartialUpdateError> =
5800            serde_json::from_str(&local_var_content).ok();
5801        let local_var_error = ResponseContent {
5802            status: local_var_status,
5803            content: local_var_content,
5804            entity: local_var_entity,
5805        };
5806        Err(Error::ResponseError(local_var_error))
5807    }
5808}
5809
5810/// Get a contact role object.
5811pub async fn tenancy_contact_roles_retrieve(
5812    configuration: &configuration::Configuration,
5813    id: i32,
5814) -> Result<crate::models::ContactRole, Error<TenancyContactRolesRetrieveError>> {
5815    let local_var_configuration = configuration;
5816
5817    let local_var_client = &local_var_configuration.client;
5818
5819    let local_var_uri_str = format!(
5820        "{}/api/tenancy/contact-roles/{id}/",
5821        local_var_configuration.base_path,
5822        id = id
5823    );
5824    let mut local_var_req_builder =
5825        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5826
5827    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5828        local_var_req_builder =
5829            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5830    }
5831    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5832        let local_var_key = local_var_apikey.key.clone();
5833        let local_var_value = match local_var_apikey.prefix {
5834            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5835            None => local_var_key,
5836        };
5837        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5838    };
5839
5840    let local_var_req = local_var_req_builder.build()?;
5841    let local_var_resp = local_var_client.execute(local_var_req).await?;
5842
5843    let local_var_status = local_var_resp.status();
5844    let local_var_content = local_var_resp.text().await?;
5845
5846    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5847        serde_json::from_str(&local_var_content).map_err(Error::from)
5848    } else {
5849        let local_var_entity: Option<TenancyContactRolesRetrieveError> =
5850            serde_json::from_str(&local_var_content).ok();
5851        let local_var_error = ResponseContent {
5852            status: local_var_status,
5853            content: local_var_content,
5854            entity: local_var_entity,
5855        };
5856        Err(Error::ResponseError(local_var_error))
5857    }
5858}
5859
5860/// Put a contact role object.
5861pub async fn tenancy_contact_roles_update(
5862    configuration: &configuration::Configuration,
5863    id: i32,
5864    contact_role_request: crate::models::ContactRoleRequest,
5865) -> Result<crate::models::ContactRole, Error<TenancyContactRolesUpdateError>> {
5866    let local_var_configuration = configuration;
5867
5868    let local_var_client = &local_var_configuration.client;
5869
5870    let local_var_uri_str = format!(
5871        "{}/api/tenancy/contact-roles/{id}/",
5872        local_var_configuration.base_path,
5873        id = id
5874    );
5875    let mut local_var_req_builder =
5876        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5877
5878    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5879        local_var_req_builder =
5880            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5881    }
5882    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5883        let local_var_key = local_var_apikey.key.clone();
5884        let local_var_value = match local_var_apikey.prefix {
5885            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5886            None => local_var_key,
5887        };
5888        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5889    };
5890    local_var_req_builder = local_var_req_builder.json(&contact_role_request);
5891
5892    let local_var_req = local_var_req_builder.build()?;
5893    let local_var_resp = local_var_client.execute(local_var_req).await?;
5894
5895    let local_var_status = local_var_resp.status();
5896    let local_var_content = local_var_resp.text().await?;
5897
5898    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5899        serde_json::from_str(&local_var_content).map_err(Error::from)
5900    } else {
5901        let local_var_entity: Option<TenancyContactRolesUpdateError> =
5902            serde_json::from_str(&local_var_content).ok();
5903        let local_var_error = ResponseContent {
5904            status: local_var_status,
5905            content: local_var_content,
5906            entity: local_var_entity,
5907        };
5908        Err(Error::ResponseError(local_var_error))
5909    }
5910}
5911
5912/// Delete a list of contact objects.
5913pub async fn tenancy_contacts_bulk_destroy(
5914    configuration: &configuration::Configuration,
5915    contact_request: Vec<crate::models::ContactRequest>,
5916) -> Result<(), Error<TenancyContactsBulkDestroyError>> {
5917    let local_var_configuration = configuration;
5918
5919    let local_var_client = &local_var_configuration.client;
5920
5921    let local_var_uri_str = format!(
5922        "{}/api/tenancy/contacts/",
5923        local_var_configuration.base_path
5924    );
5925    let mut local_var_req_builder =
5926        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5927
5928    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5929        local_var_req_builder =
5930            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5931    }
5932    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5933        let local_var_key = local_var_apikey.key.clone();
5934        let local_var_value = match local_var_apikey.prefix {
5935            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5936            None => local_var_key,
5937        };
5938        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5939    };
5940    local_var_req_builder = local_var_req_builder.json(&contact_request);
5941
5942    let local_var_req = local_var_req_builder.build()?;
5943    let local_var_resp = local_var_client.execute(local_var_req).await?;
5944
5945    let local_var_status = local_var_resp.status();
5946    let local_var_content = local_var_resp.text().await?;
5947
5948    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5949        Ok(())
5950    } else {
5951        let local_var_entity: Option<TenancyContactsBulkDestroyError> =
5952            serde_json::from_str(&local_var_content).ok();
5953        let local_var_error = ResponseContent {
5954            status: local_var_status,
5955            content: local_var_content,
5956            entity: local_var_entity,
5957        };
5958        Err(Error::ResponseError(local_var_error))
5959    }
5960}
5961
5962/// Patch a list of contact objects.
5963pub async fn tenancy_contacts_bulk_partial_update(
5964    configuration: &configuration::Configuration,
5965    contact_request: Vec<crate::models::ContactRequest>,
5966) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkPartialUpdateError>> {
5967    let local_var_configuration = configuration;
5968
5969    let local_var_client = &local_var_configuration.client;
5970
5971    let local_var_uri_str = format!(
5972        "{}/api/tenancy/contacts/",
5973        local_var_configuration.base_path
5974    );
5975    let mut local_var_req_builder =
5976        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5977
5978    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5979        local_var_req_builder =
5980            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5981    }
5982    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5983        let local_var_key = local_var_apikey.key.clone();
5984        let local_var_value = match local_var_apikey.prefix {
5985            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5986            None => local_var_key,
5987        };
5988        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5989    };
5990    local_var_req_builder = local_var_req_builder.json(&contact_request);
5991
5992    let local_var_req = local_var_req_builder.build()?;
5993    let local_var_resp = local_var_client.execute(local_var_req).await?;
5994
5995    let local_var_status = local_var_resp.status();
5996    let local_var_content = local_var_resp.text().await?;
5997
5998    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5999        serde_json::from_str(&local_var_content).map_err(Error::from)
6000    } else {
6001        let local_var_entity: Option<TenancyContactsBulkPartialUpdateError> =
6002            serde_json::from_str(&local_var_content).ok();
6003        let local_var_error = ResponseContent {
6004            status: local_var_status,
6005            content: local_var_content,
6006            entity: local_var_entity,
6007        };
6008        Err(Error::ResponseError(local_var_error))
6009    }
6010}
6011
6012/// Put a list of contact objects.
6013pub async fn tenancy_contacts_bulk_update(
6014    configuration: &configuration::Configuration,
6015    contact_request: Vec<crate::models::ContactRequest>,
6016) -> Result<Vec<crate::models::Contact>, Error<TenancyContactsBulkUpdateError>> {
6017    let local_var_configuration = configuration;
6018
6019    let local_var_client = &local_var_configuration.client;
6020
6021    let local_var_uri_str = format!(
6022        "{}/api/tenancy/contacts/",
6023        local_var_configuration.base_path
6024    );
6025    let mut local_var_req_builder =
6026        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6027
6028    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6029        local_var_req_builder =
6030            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6031    }
6032    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6033        let local_var_key = local_var_apikey.key.clone();
6034        let local_var_value = match local_var_apikey.prefix {
6035            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6036            None => local_var_key,
6037        };
6038        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6039    };
6040    local_var_req_builder = local_var_req_builder.json(&contact_request);
6041
6042    let local_var_req = local_var_req_builder.build()?;
6043    let local_var_resp = local_var_client.execute(local_var_req).await?;
6044
6045    let local_var_status = local_var_resp.status();
6046    let local_var_content = local_var_resp.text().await?;
6047
6048    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6049        serde_json::from_str(&local_var_content).map_err(Error::from)
6050    } else {
6051        let local_var_entity: Option<TenancyContactsBulkUpdateError> =
6052            serde_json::from_str(&local_var_content).ok();
6053        let local_var_error = ResponseContent {
6054            status: local_var_status,
6055            content: local_var_content,
6056            entity: local_var_entity,
6057        };
6058        Err(Error::ResponseError(local_var_error))
6059    }
6060}
6061
6062/// Post a list of contact objects.
6063pub async fn tenancy_contacts_create(
6064    configuration: &configuration::Configuration,
6065    tenancy_contacts_create_request: crate::models::TenancyContactsCreateRequest,
6066) -> Result<crate::models::Contact, Error<TenancyContactsCreateError>> {
6067    let local_var_configuration = configuration;
6068
6069    let local_var_client = &local_var_configuration.client;
6070
6071    let local_var_uri_str = format!(
6072        "{}/api/tenancy/contacts/",
6073        local_var_configuration.base_path
6074    );
6075    let mut local_var_req_builder =
6076        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6077
6078    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6079        local_var_req_builder =
6080            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6081    }
6082    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6083        let local_var_key = local_var_apikey.key.clone();
6084        let local_var_value = match local_var_apikey.prefix {
6085            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6086            None => local_var_key,
6087        };
6088        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6089    };
6090    local_var_req_builder = local_var_req_builder.json(&tenancy_contacts_create_request);
6091
6092    let local_var_req = local_var_req_builder.build()?;
6093    let local_var_resp = local_var_client.execute(local_var_req).await?;
6094
6095    let local_var_status = local_var_resp.status();
6096    let local_var_content = local_var_resp.text().await?;
6097
6098    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6099        serde_json::from_str(&local_var_content).map_err(Error::from)
6100    } else {
6101        let local_var_entity: Option<TenancyContactsCreateError> =
6102            serde_json::from_str(&local_var_content).ok();
6103        let local_var_error = ResponseContent {
6104            status: local_var_status,
6105            content: local_var_content,
6106            entity: local_var_entity,
6107        };
6108        Err(Error::ResponseError(local_var_error))
6109    }
6110}
6111
6112/// Delete a contact object.
6113pub async fn tenancy_contacts_destroy(
6114    configuration: &configuration::Configuration,
6115    id: i32,
6116) -> Result<(), Error<TenancyContactsDestroyError>> {
6117    let local_var_configuration = configuration;
6118
6119    let local_var_client = &local_var_configuration.client;
6120
6121    let local_var_uri_str = format!(
6122        "{}/api/tenancy/contacts/{id}/",
6123        local_var_configuration.base_path,
6124        id = id
6125    );
6126    let mut local_var_req_builder =
6127        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6128
6129    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6130        local_var_req_builder =
6131            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6132    }
6133    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6134        let local_var_key = local_var_apikey.key.clone();
6135        let local_var_value = match local_var_apikey.prefix {
6136            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6137            None => local_var_key,
6138        };
6139        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6140    };
6141
6142    let local_var_req = local_var_req_builder.build()?;
6143    let local_var_resp = local_var_client.execute(local_var_req).await?;
6144
6145    let local_var_status = local_var_resp.status();
6146    let local_var_content = local_var_resp.text().await?;
6147
6148    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6149        Ok(())
6150    } else {
6151        let local_var_entity: Option<TenancyContactsDestroyError> =
6152            serde_json::from_str(&local_var_content).ok();
6153        let local_var_error = ResponseContent {
6154            status: local_var_status,
6155            content: local_var_content,
6156            entity: local_var_entity,
6157        };
6158        Err(Error::ResponseError(local_var_error))
6159    }
6160}
6161
6162/// Get a list of contact objects.
6163pub async fn tenancy_contacts_list(
6164    configuration: &configuration::Configuration,
6165    address: Option<Vec<String>>,
6166    address__empty: Option<bool>,
6167    address__ic: Option<Vec<String>>,
6168    address__ie: Option<Vec<String>>,
6169    address__iew: Option<Vec<String>>,
6170    address__iregex: Option<Vec<String>>,
6171    address__isw: Option<Vec<String>>,
6172    address__n: Option<Vec<String>>,
6173    address__nic: Option<Vec<String>>,
6174    address__nie: Option<Vec<String>>,
6175    address__niew: Option<Vec<String>>,
6176    address__nisw: Option<Vec<String>>,
6177    address__regex: Option<Vec<String>>,
6178    created: Option<Vec<String>>,
6179    created__empty: Option<Vec<String>>,
6180    created__gt: Option<Vec<String>>,
6181    created__gte: Option<Vec<String>>,
6182    created__lt: Option<Vec<String>>,
6183    created__lte: Option<Vec<String>>,
6184    created__n: Option<Vec<String>>,
6185    created_by_request: Option<&str>,
6186    description: Option<Vec<String>>,
6187    description__empty: Option<bool>,
6188    description__ic: Option<Vec<String>>,
6189    description__ie: Option<Vec<String>>,
6190    description__iew: Option<Vec<String>>,
6191    description__iregex: Option<Vec<String>>,
6192    description__isw: Option<Vec<String>>,
6193    description__n: Option<Vec<String>>,
6194    description__nic: Option<Vec<String>>,
6195    description__nie: Option<Vec<String>>,
6196    description__niew: Option<Vec<String>>,
6197    description__nisw: Option<Vec<String>>,
6198    description__regex: Option<Vec<String>>,
6199    email: Option<Vec<String>>,
6200    email__empty: Option<bool>,
6201    email__ic: Option<Vec<String>>,
6202    email__ie: Option<Vec<String>>,
6203    email__iew: Option<Vec<String>>,
6204    email__iregex: Option<Vec<String>>,
6205    email__isw: Option<Vec<String>>,
6206    email__n: Option<Vec<String>>,
6207    email__nic: Option<Vec<String>>,
6208    email__nie: Option<Vec<String>>,
6209    email__niew: Option<Vec<String>>,
6210    email__nisw: Option<Vec<String>>,
6211    email__regex: Option<Vec<String>>,
6212    group: Option<Vec<String>>,
6213    group__n: Option<Vec<String>>,
6214    group_id: Option<Vec<String>>,
6215    group_id__n: Option<Vec<String>>,
6216    id: Option<Vec<i32>>,
6217    id__empty: Option<bool>,
6218    id__gt: Option<Vec<i32>>,
6219    id__gte: Option<Vec<i32>>,
6220    id__lt: Option<Vec<i32>>,
6221    id__lte: Option<Vec<i32>>,
6222    id__n: Option<Vec<i32>>,
6223    last_updated: Option<Vec<String>>,
6224    last_updated__empty: Option<Vec<String>>,
6225    last_updated__gt: Option<Vec<String>>,
6226    last_updated__gte: Option<Vec<String>>,
6227    last_updated__lt: Option<Vec<String>>,
6228    last_updated__lte: Option<Vec<String>>,
6229    last_updated__n: Option<Vec<String>>,
6230    limit: Option<i32>,
6231    link: Option<Vec<String>>,
6232    link__empty: Option<bool>,
6233    link__ic: Option<Vec<String>>,
6234    link__ie: Option<Vec<String>>,
6235    link__iew: Option<Vec<String>>,
6236    link__iregex: Option<Vec<String>>,
6237    link__isw: Option<Vec<String>>,
6238    link__n: Option<Vec<String>>,
6239    link__nic: Option<Vec<String>>,
6240    link__nie: Option<Vec<String>>,
6241    link__niew: Option<Vec<String>>,
6242    link__nisw: Option<Vec<String>>,
6243    link__regex: Option<Vec<String>>,
6244    modified_by_request: Option<&str>,
6245    name: Option<Vec<String>>,
6246    name__empty: Option<bool>,
6247    name__ic: Option<Vec<String>>,
6248    name__ie: Option<Vec<String>>,
6249    name__iew: Option<Vec<String>>,
6250    name__iregex: Option<Vec<String>>,
6251    name__isw: Option<Vec<String>>,
6252    name__n: Option<Vec<String>>,
6253    name__nic: Option<Vec<String>>,
6254    name__nie: Option<Vec<String>>,
6255    name__niew: Option<Vec<String>>,
6256    name__nisw: Option<Vec<String>>,
6257    name__regex: Option<Vec<String>>,
6258    offset: Option<i32>,
6259    ordering: Option<&str>,
6260    owner: Option<Vec<String>>,
6261    owner__n: Option<Vec<String>>,
6262    owner_group: Option<Vec<String>>,
6263    owner_group__n: Option<Vec<String>>,
6264    owner_group_id: Option<Vec<i32>>,
6265    owner_group_id__n: Option<Vec<i32>>,
6266    owner_id: Option<Vec<i32>>,
6267    owner_id__n: Option<Vec<i32>>,
6268    phone: Option<Vec<String>>,
6269    phone__empty: Option<bool>,
6270    phone__ic: Option<Vec<String>>,
6271    phone__ie: Option<Vec<String>>,
6272    phone__iew: Option<Vec<String>>,
6273    phone__iregex: Option<Vec<String>>,
6274    phone__isw: Option<Vec<String>>,
6275    phone__n: Option<Vec<String>>,
6276    phone__nic: Option<Vec<String>>,
6277    phone__nie: Option<Vec<String>>,
6278    phone__niew: Option<Vec<String>>,
6279    phone__nisw: Option<Vec<String>>,
6280    phone__regex: Option<Vec<String>>,
6281    q: Option<&str>,
6282    start: Option<i32>,
6283    tag: Option<Vec<String>>,
6284    tag__n: Option<Vec<String>>,
6285    tag_id: Option<Vec<i32>>,
6286    tag_id__n: Option<Vec<i32>>,
6287    title: Option<Vec<String>>,
6288    title__empty: Option<bool>,
6289    title__ic: Option<Vec<String>>,
6290    title__ie: Option<Vec<String>>,
6291    title__iew: Option<Vec<String>>,
6292    title__iregex: Option<Vec<String>>,
6293    title__isw: Option<Vec<String>>,
6294    title__n: Option<Vec<String>>,
6295    title__nic: Option<Vec<String>>,
6296    title__nie: Option<Vec<String>>,
6297    title__niew: Option<Vec<String>>,
6298    title__nisw: Option<Vec<String>>,
6299    title__regex: Option<Vec<String>>,
6300    updated_by_request: Option<&str>,
6301) -> Result<crate::models::PaginatedContactList, Error<TenancyContactsListError>> {
6302    let local_var_configuration = configuration;
6303
6304    let local_var_client = &local_var_configuration.client;
6305
6306    let local_var_uri_str = format!(
6307        "{}/api/tenancy/contacts/",
6308        local_var_configuration.base_path
6309    );
6310    let mut local_var_req_builder =
6311        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6312
6313    if let Some(ref local_var_str) = address {
6314        local_var_req_builder = match "multi" {
6315            "multi" => local_var_req_builder.query(
6316                &local_var_str
6317                    .into_iter()
6318                    .map(|p| ("address".to_owned(), p.to_string()))
6319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6320            ),
6321            _ => local_var_req_builder.query(&[(
6322                "address",
6323                &local_var_str
6324                    .into_iter()
6325                    .map(|p| p.to_string())
6326                    .collect::<Vec<String>>()
6327                    .join(",")
6328                    .to_string(),
6329            )]),
6330        };
6331    }
6332    if let Some(ref local_var_str) = address__empty {
6333        local_var_req_builder =
6334            local_var_req_builder.query(&[("address__empty", &local_var_str.to_string())]);
6335    }
6336    if let Some(ref local_var_str) = address__ic {
6337        local_var_req_builder = match "multi" {
6338            "multi" => local_var_req_builder.query(
6339                &local_var_str
6340                    .into_iter()
6341                    .map(|p| ("address__ic".to_owned(), p.to_string()))
6342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6343            ),
6344            _ => local_var_req_builder.query(&[(
6345                "address__ic",
6346                &local_var_str
6347                    .into_iter()
6348                    .map(|p| p.to_string())
6349                    .collect::<Vec<String>>()
6350                    .join(",")
6351                    .to_string(),
6352            )]),
6353        };
6354    }
6355    if let Some(ref local_var_str) = address__ie {
6356        local_var_req_builder = match "multi" {
6357            "multi" => local_var_req_builder.query(
6358                &local_var_str
6359                    .into_iter()
6360                    .map(|p| ("address__ie".to_owned(), p.to_string()))
6361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6362            ),
6363            _ => local_var_req_builder.query(&[(
6364                "address__ie",
6365                &local_var_str
6366                    .into_iter()
6367                    .map(|p| p.to_string())
6368                    .collect::<Vec<String>>()
6369                    .join(",")
6370                    .to_string(),
6371            )]),
6372        };
6373    }
6374    if let Some(ref local_var_str) = address__iew {
6375        local_var_req_builder = match "multi" {
6376            "multi" => local_var_req_builder.query(
6377                &local_var_str
6378                    .into_iter()
6379                    .map(|p| ("address__iew".to_owned(), p.to_string()))
6380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6381            ),
6382            _ => local_var_req_builder.query(&[(
6383                "address__iew",
6384                &local_var_str
6385                    .into_iter()
6386                    .map(|p| p.to_string())
6387                    .collect::<Vec<String>>()
6388                    .join(",")
6389                    .to_string(),
6390            )]),
6391        };
6392    }
6393    if let Some(ref local_var_str) = address__iregex {
6394        local_var_req_builder = match "multi" {
6395            "multi" => local_var_req_builder.query(
6396                &local_var_str
6397                    .into_iter()
6398                    .map(|p| ("address__iregex".to_owned(), p.to_string()))
6399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6400            ),
6401            _ => local_var_req_builder.query(&[(
6402                "address__iregex",
6403                &local_var_str
6404                    .into_iter()
6405                    .map(|p| p.to_string())
6406                    .collect::<Vec<String>>()
6407                    .join(",")
6408                    .to_string(),
6409            )]),
6410        };
6411    }
6412    if let Some(ref local_var_str) = address__isw {
6413        local_var_req_builder = match "multi" {
6414            "multi" => local_var_req_builder.query(
6415                &local_var_str
6416                    .into_iter()
6417                    .map(|p| ("address__isw".to_owned(), p.to_string()))
6418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6419            ),
6420            _ => local_var_req_builder.query(&[(
6421                "address__isw",
6422                &local_var_str
6423                    .into_iter()
6424                    .map(|p| p.to_string())
6425                    .collect::<Vec<String>>()
6426                    .join(",")
6427                    .to_string(),
6428            )]),
6429        };
6430    }
6431    if let Some(ref local_var_str) = address__n {
6432        local_var_req_builder = match "multi" {
6433            "multi" => local_var_req_builder.query(
6434                &local_var_str
6435                    .into_iter()
6436                    .map(|p| ("address__n".to_owned(), p.to_string()))
6437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6438            ),
6439            _ => local_var_req_builder.query(&[(
6440                "address__n",
6441                &local_var_str
6442                    .into_iter()
6443                    .map(|p| p.to_string())
6444                    .collect::<Vec<String>>()
6445                    .join(",")
6446                    .to_string(),
6447            )]),
6448        };
6449    }
6450    if let Some(ref local_var_str) = address__nic {
6451        local_var_req_builder = match "multi" {
6452            "multi" => local_var_req_builder.query(
6453                &local_var_str
6454                    .into_iter()
6455                    .map(|p| ("address__nic".to_owned(), p.to_string()))
6456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6457            ),
6458            _ => local_var_req_builder.query(&[(
6459                "address__nic",
6460                &local_var_str
6461                    .into_iter()
6462                    .map(|p| p.to_string())
6463                    .collect::<Vec<String>>()
6464                    .join(",")
6465                    .to_string(),
6466            )]),
6467        };
6468    }
6469    if let Some(ref local_var_str) = address__nie {
6470        local_var_req_builder = match "multi" {
6471            "multi" => local_var_req_builder.query(
6472                &local_var_str
6473                    .into_iter()
6474                    .map(|p| ("address__nie".to_owned(), p.to_string()))
6475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6476            ),
6477            _ => local_var_req_builder.query(&[(
6478                "address__nie",
6479                &local_var_str
6480                    .into_iter()
6481                    .map(|p| p.to_string())
6482                    .collect::<Vec<String>>()
6483                    .join(",")
6484                    .to_string(),
6485            )]),
6486        };
6487    }
6488    if let Some(ref local_var_str) = address__niew {
6489        local_var_req_builder = match "multi" {
6490            "multi" => local_var_req_builder.query(
6491                &local_var_str
6492                    .into_iter()
6493                    .map(|p| ("address__niew".to_owned(), p.to_string()))
6494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6495            ),
6496            _ => local_var_req_builder.query(&[(
6497                "address__niew",
6498                &local_var_str
6499                    .into_iter()
6500                    .map(|p| p.to_string())
6501                    .collect::<Vec<String>>()
6502                    .join(",")
6503                    .to_string(),
6504            )]),
6505        };
6506    }
6507    if let Some(ref local_var_str) = address__nisw {
6508        local_var_req_builder = match "multi" {
6509            "multi" => local_var_req_builder.query(
6510                &local_var_str
6511                    .into_iter()
6512                    .map(|p| ("address__nisw".to_owned(), p.to_string()))
6513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6514            ),
6515            _ => local_var_req_builder.query(&[(
6516                "address__nisw",
6517                &local_var_str
6518                    .into_iter()
6519                    .map(|p| p.to_string())
6520                    .collect::<Vec<String>>()
6521                    .join(",")
6522                    .to_string(),
6523            )]),
6524        };
6525    }
6526    if let Some(ref local_var_str) = address__regex {
6527        local_var_req_builder = match "multi" {
6528            "multi" => local_var_req_builder.query(
6529                &local_var_str
6530                    .into_iter()
6531                    .map(|p| ("address__regex".to_owned(), p.to_string()))
6532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6533            ),
6534            _ => local_var_req_builder.query(&[(
6535                "address__regex",
6536                &local_var_str
6537                    .into_iter()
6538                    .map(|p| p.to_string())
6539                    .collect::<Vec<String>>()
6540                    .join(",")
6541                    .to_string(),
6542            )]),
6543        };
6544    }
6545    if let Some(ref local_var_str) = created {
6546        local_var_req_builder = match "multi" {
6547            "multi" => local_var_req_builder.query(
6548                &local_var_str
6549                    .into_iter()
6550                    .map(|p| ("created".to_owned(), p.to_string()))
6551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6552            ),
6553            _ => local_var_req_builder.query(&[(
6554                "created",
6555                &local_var_str
6556                    .into_iter()
6557                    .map(|p| p.to_string())
6558                    .collect::<Vec<String>>()
6559                    .join(",")
6560                    .to_string(),
6561            )]),
6562        };
6563    }
6564    if let Some(ref local_var_str) = created__empty {
6565        local_var_req_builder = match "multi" {
6566            "multi" => local_var_req_builder.query(
6567                &local_var_str
6568                    .into_iter()
6569                    .map(|p| ("created__empty".to_owned(), p.to_string()))
6570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6571            ),
6572            _ => local_var_req_builder.query(&[(
6573                "created__empty",
6574                &local_var_str
6575                    .into_iter()
6576                    .map(|p| p.to_string())
6577                    .collect::<Vec<String>>()
6578                    .join(",")
6579                    .to_string(),
6580            )]),
6581        };
6582    }
6583    if let Some(ref local_var_str) = created__gt {
6584        local_var_req_builder = match "multi" {
6585            "multi" => local_var_req_builder.query(
6586                &local_var_str
6587                    .into_iter()
6588                    .map(|p| ("created__gt".to_owned(), p.to_string()))
6589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6590            ),
6591            _ => local_var_req_builder.query(&[(
6592                "created__gt",
6593                &local_var_str
6594                    .into_iter()
6595                    .map(|p| p.to_string())
6596                    .collect::<Vec<String>>()
6597                    .join(",")
6598                    .to_string(),
6599            )]),
6600        };
6601    }
6602    if let Some(ref local_var_str) = created__gte {
6603        local_var_req_builder = match "multi" {
6604            "multi" => local_var_req_builder.query(
6605                &local_var_str
6606                    .into_iter()
6607                    .map(|p| ("created__gte".to_owned(), p.to_string()))
6608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6609            ),
6610            _ => local_var_req_builder.query(&[(
6611                "created__gte",
6612                &local_var_str
6613                    .into_iter()
6614                    .map(|p| p.to_string())
6615                    .collect::<Vec<String>>()
6616                    .join(",")
6617                    .to_string(),
6618            )]),
6619        };
6620    }
6621    if let Some(ref local_var_str) = created__lt {
6622        local_var_req_builder = match "multi" {
6623            "multi" => local_var_req_builder.query(
6624                &local_var_str
6625                    .into_iter()
6626                    .map(|p| ("created__lt".to_owned(), p.to_string()))
6627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6628            ),
6629            _ => local_var_req_builder.query(&[(
6630                "created__lt",
6631                &local_var_str
6632                    .into_iter()
6633                    .map(|p| p.to_string())
6634                    .collect::<Vec<String>>()
6635                    .join(",")
6636                    .to_string(),
6637            )]),
6638        };
6639    }
6640    if let Some(ref local_var_str) = created__lte {
6641        local_var_req_builder = match "multi" {
6642            "multi" => local_var_req_builder.query(
6643                &local_var_str
6644                    .into_iter()
6645                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6647            ),
6648            _ => local_var_req_builder.query(&[(
6649                "created__lte",
6650                &local_var_str
6651                    .into_iter()
6652                    .map(|p| p.to_string())
6653                    .collect::<Vec<String>>()
6654                    .join(",")
6655                    .to_string(),
6656            )]),
6657        };
6658    }
6659    if let Some(ref local_var_str) = created__n {
6660        local_var_req_builder = match "multi" {
6661            "multi" => local_var_req_builder.query(
6662                &local_var_str
6663                    .into_iter()
6664                    .map(|p| ("created__n".to_owned(), p.to_string()))
6665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6666            ),
6667            _ => local_var_req_builder.query(&[(
6668                "created__n",
6669                &local_var_str
6670                    .into_iter()
6671                    .map(|p| p.to_string())
6672                    .collect::<Vec<String>>()
6673                    .join(",")
6674                    .to_string(),
6675            )]),
6676        };
6677    }
6678    if let Some(ref local_var_str) = created_by_request {
6679        local_var_req_builder =
6680            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
6681    }
6682    if let Some(ref local_var_str) = description {
6683        local_var_req_builder = match "multi" {
6684            "multi" => local_var_req_builder.query(
6685                &local_var_str
6686                    .into_iter()
6687                    .map(|p| ("description".to_owned(), p.to_string()))
6688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6689            ),
6690            _ => local_var_req_builder.query(&[(
6691                "description",
6692                &local_var_str
6693                    .into_iter()
6694                    .map(|p| p.to_string())
6695                    .collect::<Vec<String>>()
6696                    .join(",")
6697                    .to_string(),
6698            )]),
6699        };
6700    }
6701    if let Some(ref local_var_str) = description__empty {
6702        local_var_req_builder =
6703            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6704    }
6705    if let Some(ref local_var_str) = description__ic {
6706        local_var_req_builder = match "multi" {
6707            "multi" => local_var_req_builder.query(
6708                &local_var_str
6709                    .into_iter()
6710                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6712            ),
6713            _ => local_var_req_builder.query(&[(
6714                "description__ic",
6715                &local_var_str
6716                    .into_iter()
6717                    .map(|p| p.to_string())
6718                    .collect::<Vec<String>>()
6719                    .join(",")
6720                    .to_string(),
6721            )]),
6722        };
6723    }
6724    if let Some(ref local_var_str) = description__ie {
6725        local_var_req_builder = match "multi" {
6726            "multi" => local_var_req_builder.query(
6727                &local_var_str
6728                    .into_iter()
6729                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6731            ),
6732            _ => local_var_req_builder.query(&[(
6733                "description__ie",
6734                &local_var_str
6735                    .into_iter()
6736                    .map(|p| p.to_string())
6737                    .collect::<Vec<String>>()
6738                    .join(",")
6739                    .to_string(),
6740            )]),
6741        };
6742    }
6743    if let Some(ref local_var_str) = description__iew {
6744        local_var_req_builder = match "multi" {
6745            "multi" => local_var_req_builder.query(
6746                &local_var_str
6747                    .into_iter()
6748                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6750            ),
6751            _ => local_var_req_builder.query(&[(
6752                "description__iew",
6753                &local_var_str
6754                    .into_iter()
6755                    .map(|p| p.to_string())
6756                    .collect::<Vec<String>>()
6757                    .join(",")
6758                    .to_string(),
6759            )]),
6760        };
6761    }
6762    if let Some(ref local_var_str) = description__iregex {
6763        local_var_req_builder = match "multi" {
6764            "multi" => local_var_req_builder.query(
6765                &local_var_str
6766                    .into_iter()
6767                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6769            ),
6770            _ => local_var_req_builder.query(&[(
6771                "description__iregex",
6772                &local_var_str
6773                    .into_iter()
6774                    .map(|p| p.to_string())
6775                    .collect::<Vec<String>>()
6776                    .join(",")
6777                    .to_string(),
6778            )]),
6779        };
6780    }
6781    if let Some(ref local_var_str) = description__isw {
6782        local_var_req_builder = match "multi" {
6783            "multi" => local_var_req_builder.query(
6784                &local_var_str
6785                    .into_iter()
6786                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6788            ),
6789            _ => local_var_req_builder.query(&[(
6790                "description__isw",
6791                &local_var_str
6792                    .into_iter()
6793                    .map(|p| p.to_string())
6794                    .collect::<Vec<String>>()
6795                    .join(",")
6796                    .to_string(),
6797            )]),
6798        };
6799    }
6800    if let Some(ref local_var_str) = description__n {
6801        local_var_req_builder = match "multi" {
6802            "multi" => local_var_req_builder.query(
6803                &local_var_str
6804                    .into_iter()
6805                    .map(|p| ("description__n".to_owned(), p.to_string()))
6806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6807            ),
6808            _ => local_var_req_builder.query(&[(
6809                "description__n",
6810                &local_var_str
6811                    .into_iter()
6812                    .map(|p| p.to_string())
6813                    .collect::<Vec<String>>()
6814                    .join(",")
6815                    .to_string(),
6816            )]),
6817        };
6818    }
6819    if let Some(ref local_var_str) = description__nic {
6820        local_var_req_builder = match "multi" {
6821            "multi" => local_var_req_builder.query(
6822                &local_var_str
6823                    .into_iter()
6824                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6826            ),
6827            _ => local_var_req_builder.query(&[(
6828                "description__nic",
6829                &local_var_str
6830                    .into_iter()
6831                    .map(|p| p.to_string())
6832                    .collect::<Vec<String>>()
6833                    .join(",")
6834                    .to_string(),
6835            )]),
6836        };
6837    }
6838    if let Some(ref local_var_str) = description__nie {
6839        local_var_req_builder = match "multi" {
6840            "multi" => local_var_req_builder.query(
6841                &local_var_str
6842                    .into_iter()
6843                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6845            ),
6846            _ => local_var_req_builder.query(&[(
6847                "description__nie",
6848                &local_var_str
6849                    .into_iter()
6850                    .map(|p| p.to_string())
6851                    .collect::<Vec<String>>()
6852                    .join(",")
6853                    .to_string(),
6854            )]),
6855        };
6856    }
6857    if let Some(ref local_var_str) = description__niew {
6858        local_var_req_builder = match "multi" {
6859            "multi" => local_var_req_builder.query(
6860                &local_var_str
6861                    .into_iter()
6862                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6864            ),
6865            _ => local_var_req_builder.query(&[(
6866                "description__niew",
6867                &local_var_str
6868                    .into_iter()
6869                    .map(|p| p.to_string())
6870                    .collect::<Vec<String>>()
6871                    .join(",")
6872                    .to_string(),
6873            )]),
6874        };
6875    }
6876    if let Some(ref local_var_str) = description__nisw {
6877        local_var_req_builder = match "multi" {
6878            "multi" => local_var_req_builder.query(
6879                &local_var_str
6880                    .into_iter()
6881                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6883            ),
6884            _ => local_var_req_builder.query(&[(
6885                "description__nisw",
6886                &local_var_str
6887                    .into_iter()
6888                    .map(|p| p.to_string())
6889                    .collect::<Vec<String>>()
6890                    .join(",")
6891                    .to_string(),
6892            )]),
6893        };
6894    }
6895    if let Some(ref local_var_str) = description__regex {
6896        local_var_req_builder = match "multi" {
6897            "multi" => local_var_req_builder.query(
6898                &local_var_str
6899                    .into_iter()
6900                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6902            ),
6903            _ => local_var_req_builder.query(&[(
6904                "description__regex",
6905                &local_var_str
6906                    .into_iter()
6907                    .map(|p| p.to_string())
6908                    .collect::<Vec<String>>()
6909                    .join(",")
6910                    .to_string(),
6911            )]),
6912        };
6913    }
6914    if let Some(ref local_var_str) = email {
6915        local_var_req_builder = match "multi" {
6916            "multi" => local_var_req_builder.query(
6917                &local_var_str
6918                    .into_iter()
6919                    .map(|p| ("email".to_owned(), p.to_string()))
6920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6921            ),
6922            _ => local_var_req_builder.query(&[(
6923                "email",
6924                &local_var_str
6925                    .into_iter()
6926                    .map(|p| p.to_string())
6927                    .collect::<Vec<String>>()
6928                    .join(",")
6929                    .to_string(),
6930            )]),
6931        };
6932    }
6933    if let Some(ref local_var_str) = email__empty {
6934        local_var_req_builder =
6935            local_var_req_builder.query(&[("email__empty", &local_var_str.to_string())]);
6936    }
6937    if let Some(ref local_var_str) = email__ic {
6938        local_var_req_builder = match "multi" {
6939            "multi" => local_var_req_builder.query(
6940                &local_var_str
6941                    .into_iter()
6942                    .map(|p| ("email__ic".to_owned(), p.to_string()))
6943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6944            ),
6945            _ => local_var_req_builder.query(&[(
6946                "email__ic",
6947                &local_var_str
6948                    .into_iter()
6949                    .map(|p| p.to_string())
6950                    .collect::<Vec<String>>()
6951                    .join(",")
6952                    .to_string(),
6953            )]),
6954        };
6955    }
6956    if let Some(ref local_var_str) = email__ie {
6957        local_var_req_builder = match "multi" {
6958            "multi" => local_var_req_builder.query(
6959                &local_var_str
6960                    .into_iter()
6961                    .map(|p| ("email__ie".to_owned(), p.to_string()))
6962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6963            ),
6964            _ => local_var_req_builder.query(&[(
6965                "email__ie",
6966                &local_var_str
6967                    .into_iter()
6968                    .map(|p| p.to_string())
6969                    .collect::<Vec<String>>()
6970                    .join(",")
6971                    .to_string(),
6972            )]),
6973        };
6974    }
6975    if let Some(ref local_var_str) = email__iew {
6976        local_var_req_builder = match "multi" {
6977            "multi" => local_var_req_builder.query(
6978                &local_var_str
6979                    .into_iter()
6980                    .map(|p| ("email__iew".to_owned(), p.to_string()))
6981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6982            ),
6983            _ => local_var_req_builder.query(&[(
6984                "email__iew",
6985                &local_var_str
6986                    .into_iter()
6987                    .map(|p| p.to_string())
6988                    .collect::<Vec<String>>()
6989                    .join(",")
6990                    .to_string(),
6991            )]),
6992        };
6993    }
6994    if let Some(ref local_var_str) = email__iregex {
6995        local_var_req_builder = match "multi" {
6996            "multi" => local_var_req_builder.query(
6997                &local_var_str
6998                    .into_iter()
6999                    .map(|p| ("email__iregex".to_owned(), p.to_string()))
7000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7001            ),
7002            _ => local_var_req_builder.query(&[(
7003                "email__iregex",
7004                &local_var_str
7005                    .into_iter()
7006                    .map(|p| p.to_string())
7007                    .collect::<Vec<String>>()
7008                    .join(",")
7009                    .to_string(),
7010            )]),
7011        };
7012    }
7013    if let Some(ref local_var_str) = email__isw {
7014        local_var_req_builder = match "multi" {
7015            "multi" => local_var_req_builder.query(
7016                &local_var_str
7017                    .into_iter()
7018                    .map(|p| ("email__isw".to_owned(), p.to_string()))
7019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7020            ),
7021            _ => local_var_req_builder.query(&[(
7022                "email__isw",
7023                &local_var_str
7024                    .into_iter()
7025                    .map(|p| p.to_string())
7026                    .collect::<Vec<String>>()
7027                    .join(",")
7028                    .to_string(),
7029            )]),
7030        };
7031    }
7032    if let Some(ref local_var_str) = email__n {
7033        local_var_req_builder = match "multi" {
7034            "multi" => local_var_req_builder.query(
7035                &local_var_str
7036                    .into_iter()
7037                    .map(|p| ("email__n".to_owned(), p.to_string()))
7038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7039            ),
7040            _ => local_var_req_builder.query(&[(
7041                "email__n",
7042                &local_var_str
7043                    .into_iter()
7044                    .map(|p| p.to_string())
7045                    .collect::<Vec<String>>()
7046                    .join(",")
7047                    .to_string(),
7048            )]),
7049        };
7050    }
7051    if let Some(ref local_var_str) = email__nic {
7052        local_var_req_builder = match "multi" {
7053            "multi" => local_var_req_builder.query(
7054                &local_var_str
7055                    .into_iter()
7056                    .map(|p| ("email__nic".to_owned(), p.to_string()))
7057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7058            ),
7059            _ => local_var_req_builder.query(&[(
7060                "email__nic",
7061                &local_var_str
7062                    .into_iter()
7063                    .map(|p| p.to_string())
7064                    .collect::<Vec<String>>()
7065                    .join(",")
7066                    .to_string(),
7067            )]),
7068        };
7069    }
7070    if let Some(ref local_var_str) = email__nie {
7071        local_var_req_builder = match "multi" {
7072            "multi" => local_var_req_builder.query(
7073                &local_var_str
7074                    .into_iter()
7075                    .map(|p| ("email__nie".to_owned(), p.to_string()))
7076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7077            ),
7078            _ => local_var_req_builder.query(&[(
7079                "email__nie",
7080                &local_var_str
7081                    .into_iter()
7082                    .map(|p| p.to_string())
7083                    .collect::<Vec<String>>()
7084                    .join(",")
7085                    .to_string(),
7086            )]),
7087        };
7088    }
7089    if let Some(ref local_var_str) = email__niew {
7090        local_var_req_builder = match "multi" {
7091            "multi" => local_var_req_builder.query(
7092                &local_var_str
7093                    .into_iter()
7094                    .map(|p| ("email__niew".to_owned(), p.to_string()))
7095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7096            ),
7097            _ => local_var_req_builder.query(&[(
7098                "email__niew",
7099                &local_var_str
7100                    .into_iter()
7101                    .map(|p| p.to_string())
7102                    .collect::<Vec<String>>()
7103                    .join(",")
7104                    .to_string(),
7105            )]),
7106        };
7107    }
7108    if let Some(ref local_var_str) = email__nisw {
7109        local_var_req_builder = match "multi" {
7110            "multi" => local_var_req_builder.query(
7111                &local_var_str
7112                    .into_iter()
7113                    .map(|p| ("email__nisw".to_owned(), p.to_string()))
7114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7115            ),
7116            _ => local_var_req_builder.query(&[(
7117                "email__nisw",
7118                &local_var_str
7119                    .into_iter()
7120                    .map(|p| p.to_string())
7121                    .collect::<Vec<String>>()
7122                    .join(",")
7123                    .to_string(),
7124            )]),
7125        };
7126    }
7127    if let Some(ref local_var_str) = email__regex {
7128        local_var_req_builder = match "multi" {
7129            "multi" => local_var_req_builder.query(
7130                &local_var_str
7131                    .into_iter()
7132                    .map(|p| ("email__regex".to_owned(), p.to_string()))
7133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7134            ),
7135            _ => local_var_req_builder.query(&[(
7136                "email__regex",
7137                &local_var_str
7138                    .into_iter()
7139                    .map(|p| p.to_string())
7140                    .collect::<Vec<String>>()
7141                    .join(",")
7142                    .to_string(),
7143            )]),
7144        };
7145    }
7146    if let Some(ref local_var_str) = group {
7147        local_var_req_builder = match "multi" {
7148            "multi" => local_var_req_builder.query(
7149                &local_var_str
7150                    .into_iter()
7151                    .map(|p| ("group".to_owned(), p.to_string()))
7152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7153            ),
7154            _ => local_var_req_builder.query(&[(
7155                "group",
7156                &local_var_str
7157                    .into_iter()
7158                    .map(|p| p.to_string())
7159                    .collect::<Vec<String>>()
7160                    .join(",")
7161                    .to_string(),
7162            )]),
7163        };
7164    }
7165    if let Some(ref local_var_str) = group__n {
7166        local_var_req_builder = match "multi" {
7167            "multi" => local_var_req_builder.query(
7168                &local_var_str
7169                    .into_iter()
7170                    .map(|p| ("group__n".to_owned(), p.to_string()))
7171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7172            ),
7173            _ => local_var_req_builder.query(&[(
7174                "group__n",
7175                &local_var_str
7176                    .into_iter()
7177                    .map(|p| p.to_string())
7178                    .collect::<Vec<String>>()
7179                    .join(",")
7180                    .to_string(),
7181            )]),
7182        };
7183    }
7184    if let Some(ref local_var_str) = group_id {
7185        local_var_req_builder = match "multi" {
7186            "multi" => local_var_req_builder.query(
7187                &local_var_str
7188                    .into_iter()
7189                    .map(|p| ("group_id".to_owned(), p.to_string()))
7190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7191            ),
7192            _ => local_var_req_builder.query(&[(
7193                "group_id",
7194                &local_var_str
7195                    .into_iter()
7196                    .map(|p| p.to_string())
7197                    .collect::<Vec<String>>()
7198                    .join(",")
7199                    .to_string(),
7200            )]),
7201        };
7202    }
7203    if let Some(ref local_var_str) = group_id__n {
7204        local_var_req_builder = match "multi" {
7205            "multi" => local_var_req_builder.query(
7206                &local_var_str
7207                    .into_iter()
7208                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
7209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7210            ),
7211            _ => local_var_req_builder.query(&[(
7212                "group_id__n",
7213                &local_var_str
7214                    .into_iter()
7215                    .map(|p| p.to_string())
7216                    .collect::<Vec<String>>()
7217                    .join(",")
7218                    .to_string(),
7219            )]),
7220        };
7221    }
7222    if let Some(ref local_var_str) = id {
7223        local_var_req_builder = match "multi" {
7224            "multi" => local_var_req_builder.query(
7225                &local_var_str
7226                    .into_iter()
7227                    .map(|p| ("id".to_owned(), p.to_string()))
7228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7229            ),
7230            _ => local_var_req_builder.query(&[(
7231                "id",
7232                &local_var_str
7233                    .into_iter()
7234                    .map(|p| p.to_string())
7235                    .collect::<Vec<String>>()
7236                    .join(",")
7237                    .to_string(),
7238            )]),
7239        };
7240    }
7241    if let Some(ref local_var_str) = id__empty {
7242        local_var_req_builder =
7243            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7244    }
7245    if let Some(ref local_var_str) = id__gt {
7246        local_var_req_builder = match "multi" {
7247            "multi" => local_var_req_builder.query(
7248                &local_var_str
7249                    .into_iter()
7250                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7252            ),
7253            _ => local_var_req_builder.query(&[(
7254                "id__gt",
7255                &local_var_str
7256                    .into_iter()
7257                    .map(|p| p.to_string())
7258                    .collect::<Vec<String>>()
7259                    .join(",")
7260                    .to_string(),
7261            )]),
7262        };
7263    }
7264    if let Some(ref local_var_str) = id__gte {
7265        local_var_req_builder = match "multi" {
7266            "multi" => local_var_req_builder.query(
7267                &local_var_str
7268                    .into_iter()
7269                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7271            ),
7272            _ => local_var_req_builder.query(&[(
7273                "id__gte",
7274                &local_var_str
7275                    .into_iter()
7276                    .map(|p| p.to_string())
7277                    .collect::<Vec<String>>()
7278                    .join(",")
7279                    .to_string(),
7280            )]),
7281        };
7282    }
7283    if let Some(ref local_var_str) = id__lt {
7284        local_var_req_builder = match "multi" {
7285            "multi" => local_var_req_builder.query(
7286                &local_var_str
7287                    .into_iter()
7288                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7290            ),
7291            _ => local_var_req_builder.query(&[(
7292                "id__lt",
7293                &local_var_str
7294                    .into_iter()
7295                    .map(|p| p.to_string())
7296                    .collect::<Vec<String>>()
7297                    .join(",")
7298                    .to_string(),
7299            )]),
7300        };
7301    }
7302    if let Some(ref local_var_str) = id__lte {
7303        local_var_req_builder = match "multi" {
7304            "multi" => local_var_req_builder.query(
7305                &local_var_str
7306                    .into_iter()
7307                    .map(|p| ("id__lte".to_owned(), p.to_string()))
7308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7309            ),
7310            _ => local_var_req_builder.query(&[(
7311                "id__lte",
7312                &local_var_str
7313                    .into_iter()
7314                    .map(|p| p.to_string())
7315                    .collect::<Vec<String>>()
7316                    .join(",")
7317                    .to_string(),
7318            )]),
7319        };
7320    }
7321    if let Some(ref local_var_str) = id__n {
7322        local_var_req_builder = match "multi" {
7323            "multi" => local_var_req_builder.query(
7324                &local_var_str
7325                    .into_iter()
7326                    .map(|p| ("id__n".to_owned(), p.to_string()))
7327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7328            ),
7329            _ => local_var_req_builder.query(&[(
7330                "id__n",
7331                &local_var_str
7332                    .into_iter()
7333                    .map(|p| p.to_string())
7334                    .collect::<Vec<String>>()
7335                    .join(",")
7336                    .to_string(),
7337            )]),
7338        };
7339    }
7340    if let Some(ref local_var_str) = last_updated {
7341        local_var_req_builder = match "multi" {
7342            "multi" => local_var_req_builder.query(
7343                &local_var_str
7344                    .into_iter()
7345                    .map(|p| ("last_updated".to_owned(), p.to_string()))
7346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7347            ),
7348            _ => local_var_req_builder.query(&[(
7349                "last_updated",
7350                &local_var_str
7351                    .into_iter()
7352                    .map(|p| p.to_string())
7353                    .collect::<Vec<String>>()
7354                    .join(",")
7355                    .to_string(),
7356            )]),
7357        };
7358    }
7359    if let Some(ref local_var_str) = last_updated__empty {
7360        local_var_req_builder = match "multi" {
7361            "multi" => local_var_req_builder.query(
7362                &local_var_str
7363                    .into_iter()
7364                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
7365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7366            ),
7367            _ => local_var_req_builder.query(&[(
7368                "last_updated__empty",
7369                &local_var_str
7370                    .into_iter()
7371                    .map(|p| p.to_string())
7372                    .collect::<Vec<String>>()
7373                    .join(",")
7374                    .to_string(),
7375            )]),
7376        };
7377    }
7378    if let Some(ref local_var_str) = last_updated__gt {
7379        local_var_req_builder = match "multi" {
7380            "multi" => local_var_req_builder.query(
7381                &local_var_str
7382                    .into_iter()
7383                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
7384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7385            ),
7386            _ => local_var_req_builder.query(&[(
7387                "last_updated__gt",
7388                &local_var_str
7389                    .into_iter()
7390                    .map(|p| p.to_string())
7391                    .collect::<Vec<String>>()
7392                    .join(",")
7393                    .to_string(),
7394            )]),
7395        };
7396    }
7397    if let Some(ref local_var_str) = last_updated__gte {
7398        local_var_req_builder = match "multi" {
7399            "multi" => local_var_req_builder.query(
7400                &local_var_str
7401                    .into_iter()
7402                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
7403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7404            ),
7405            _ => local_var_req_builder.query(&[(
7406                "last_updated__gte",
7407                &local_var_str
7408                    .into_iter()
7409                    .map(|p| p.to_string())
7410                    .collect::<Vec<String>>()
7411                    .join(",")
7412                    .to_string(),
7413            )]),
7414        };
7415    }
7416    if let Some(ref local_var_str) = last_updated__lt {
7417        local_var_req_builder = match "multi" {
7418            "multi" => local_var_req_builder.query(
7419                &local_var_str
7420                    .into_iter()
7421                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
7422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7423            ),
7424            _ => local_var_req_builder.query(&[(
7425                "last_updated__lt",
7426                &local_var_str
7427                    .into_iter()
7428                    .map(|p| p.to_string())
7429                    .collect::<Vec<String>>()
7430                    .join(",")
7431                    .to_string(),
7432            )]),
7433        };
7434    }
7435    if let Some(ref local_var_str) = last_updated__lte {
7436        local_var_req_builder = match "multi" {
7437            "multi" => local_var_req_builder.query(
7438                &local_var_str
7439                    .into_iter()
7440                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
7441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7442            ),
7443            _ => local_var_req_builder.query(&[(
7444                "last_updated__lte",
7445                &local_var_str
7446                    .into_iter()
7447                    .map(|p| p.to_string())
7448                    .collect::<Vec<String>>()
7449                    .join(",")
7450                    .to_string(),
7451            )]),
7452        };
7453    }
7454    if let Some(ref local_var_str) = last_updated__n {
7455        local_var_req_builder = match "multi" {
7456            "multi" => local_var_req_builder.query(
7457                &local_var_str
7458                    .into_iter()
7459                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
7460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7461            ),
7462            _ => local_var_req_builder.query(&[(
7463                "last_updated__n",
7464                &local_var_str
7465                    .into_iter()
7466                    .map(|p| p.to_string())
7467                    .collect::<Vec<String>>()
7468                    .join(",")
7469                    .to_string(),
7470            )]),
7471        };
7472    }
7473    if let Some(ref local_var_str) = limit {
7474        local_var_req_builder =
7475            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7476    }
7477    if let Some(ref local_var_str) = link {
7478        local_var_req_builder = match "multi" {
7479            "multi" => local_var_req_builder.query(
7480                &local_var_str
7481                    .into_iter()
7482                    .map(|p| ("link".to_owned(), p.to_string()))
7483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7484            ),
7485            _ => local_var_req_builder.query(&[(
7486                "link",
7487                &local_var_str
7488                    .into_iter()
7489                    .map(|p| p.to_string())
7490                    .collect::<Vec<String>>()
7491                    .join(",")
7492                    .to_string(),
7493            )]),
7494        };
7495    }
7496    if let Some(ref local_var_str) = link__empty {
7497        local_var_req_builder =
7498            local_var_req_builder.query(&[("link__empty", &local_var_str.to_string())]);
7499    }
7500    if let Some(ref local_var_str) = link__ic {
7501        local_var_req_builder = match "multi" {
7502            "multi" => local_var_req_builder.query(
7503                &local_var_str
7504                    .into_iter()
7505                    .map(|p| ("link__ic".to_owned(), p.to_string()))
7506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7507            ),
7508            _ => local_var_req_builder.query(&[(
7509                "link__ic",
7510                &local_var_str
7511                    .into_iter()
7512                    .map(|p| p.to_string())
7513                    .collect::<Vec<String>>()
7514                    .join(",")
7515                    .to_string(),
7516            )]),
7517        };
7518    }
7519    if let Some(ref local_var_str) = link__ie {
7520        local_var_req_builder = match "multi" {
7521            "multi" => local_var_req_builder.query(
7522                &local_var_str
7523                    .into_iter()
7524                    .map(|p| ("link__ie".to_owned(), p.to_string()))
7525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7526            ),
7527            _ => local_var_req_builder.query(&[(
7528                "link__ie",
7529                &local_var_str
7530                    .into_iter()
7531                    .map(|p| p.to_string())
7532                    .collect::<Vec<String>>()
7533                    .join(",")
7534                    .to_string(),
7535            )]),
7536        };
7537    }
7538    if let Some(ref local_var_str) = link__iew {
7539        local_var_req_builder = match "multi" {
7540            "multi" => local_var_req_builder.query(
7541                &local_var_str
7542                    .into_iter()
7543                    .map(|p| ("link__iew".to_owned(), p.to_string()))
7544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7545            ),
7546            _ => local_var_req_builder.query(&[(
7547                "link__iew",
7548                &local_var_str
7549                    .into_iter()
7550                    .map(|p| p.to_string())
7551                    .collect::<Vec<String>>()
7552                    .join(",")
7553                    .to_string(),
7554            )]),
7555        };
7556    }
7557    if let Some(ref local_var_str) = link__iregex {
7558        local_var_req_builder = match "multi" {
7559            "multi" => local_var_req_builder.query(
7560                &local_var_str
7561                    .into_iter()
7562                    .map(|p| ("link__iregex".to_owned(), p.to_string()))
7563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7564            ),
7565            _ => local_var_req_builder.query(&[(
7566                "link__iregex",
7567                &local_var_str
7568                    .into_iter()
7569                    .map(|p| p.to_string())
7570                    .collect::<Vec<String>>()
7571                    .join(",")
7572                    .to_string(),
7573            )]),
7574        };
7575    }
7576    if let Some(ref local_var_str) = link__isw {
7577        local_var_req_builder = match "multi" {
7578            "multi" => local_var_req_builder.query(
7579                &local_var_str
7580                    .into_iter()
7581                    .map(|p| ("link__isw".to_owned(), p.to_string()))
7582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7583            ),
7584            _ => local_var_req_builder.query(&[(
7585                "link__isw",
7586                &local_var_str
7587                    .into_iter()
7588                    .map(|p| p.to_string())
7589                    .collect::<Vec<String>>()
7590                    .join(",")
7591                    .to_string(),
7592            )]),
7593        };
7594    }
7595    if let Some(ref local_var_str) = link__n {
7596        local_var_req_builder = match "multi" {
7597            "multi" => local_var_req_builder.query(
7598                &local_var_str
7599                    .into_iter()
7600                    .map(|p| ("link__n".to_owned(), p.to_string()))
7601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7602            ),
7603            _ => local_var_req_builder.query(&[(
7604                "link__n",
7605                &local_var_str
7606                    .into_iter()
7607                    .map(|p| p.to_string())
7608                    .collect::<Vec<String>>()
7609                    .join(",")
7610                    .to_string(),
7611            )]),
7612        };
7613    }
7614    if let Some(ref local_var_str) = link__nic {
7615        local_var_req_builder = match "multi" {
7616            "multi" => local_var_req_builder.query(
7617                &local_var_str
7618                    .into_iter()
7619                    .map(|p| ("link__nic".to_owned(), p.to_string()))
7620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7621            ),
7622            _ => local_var_req_builder.query(&[(
7623                "link__nic",
7624                &local_var_str
7625                    .into_iter()
7626                    .map(|p| p.to_string())
7627                    .collect::<Vec<String>>()
7628                    .join(",")
7629                    .to_string(),
7630            )]),
7631        };
7632    }
7633    if let Some(ref local_var_str) = link__nie {
7634        local_var_req_builder = match "multi" {
7635            "multi" => local_var_req_builder.query(
7636                &local_var_str
7637                    .into_iter()
7638                    .map(|p| ("link__nie".to_owned(), p.to_string()))
7639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7640            ),
7641            _ => local_var_req_builder.query(&[(
7642                "link__nie",
7643                &local_var_str
7644                    .into_iter()
7645                    .map(|p| p.to_string())
7646                    .collect::<Vec<String>>()
7647                    .join(",")
7648                    .to_string(),
7649            )]),
7650        };
7651    }
7652    if let Some(ref local_var_str) = link__niew {
7653        local_var_req_builder = match "multi" {
7654            "multi" => local_var_req_builder.query(
7655                &local_var_str
7656                    .into_iter()
7657                    .map(|p| ("link__niew".to_owned(), p.to_string()))
7658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7659            ),
7660            _ => local_var_req_builder.query(&[(
7661                "link__niew",
7662                &local_var_str
7663                    .into_iter()
7664                    .map(|p| p.to_string())
7665                    .collect::<Vec<String>>()
7666                    .join(",")
7667                    .to_string(),
7668            )]),
7669        };
7670    }
7671    if let Some(ref local_var_str) = link__nisw {
7672        local_var_req_builder = match "multi" {
7673            "multi" => local_var_req_builder.query(
7674                &local_var_str
7675                    .into_iter()
7676                    .map(|p| ("link__nisw".to_owned(), p.to_string()))
7677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7678            ),
7679            _ => local_var_req_builder.query(&[(
7680                "link__nisw",
7681                &local_var_str
7682                    .into_iter()
7683                    .map(|p| p.to_string())
7684                    .collect::<Vec<String>>()
7685                    .join(",")
7686                    .to_string(),
7687            )]),
7688        };
7689    }
7690    if let Some(ref local_var_str) = link__regex {
7691        local_var_req_builder = match "multi" {
7692            "multi" => local_var_req_builder.query(
7693                &local_var_str
7694                    .into_iter()
7695                    .map(|p| ("link__regex".to_owned(), p.to_string()))
7696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7697            ),
7698            _ => local_var_req_builder.query(&[(
7699                "link__regex",
7700                &local_var_str
7701                    .into_iter()
7702                    .map(|p| p.to_string())
7703                    .collect::<Vec<String>>()
7704                    .join(",")
7705                    .to_string(),
7706            )]),
7707        };
7708    }
7709    if let Some(ref local_var_str) = modified_by_request {
7710        local_var_req_builder =
7711            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
7712    }
7713    if let Some(ref local_var_str) = name {
7714        local_var_req_builder = match "multi" {
7715            "multi" => local_var_req_builder.query(
7716                &local_var_str
7717                    .into_iter()
7718                    .map(|p| ("name".to_owned(), p.to_string()))
7719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7720            ),
7721            _ => local_var_req_builder.query(&[(
7722                "name",
7723                &local_var_str
7724                    .into_iter()
7725                    .map(|p| p.to_string())
7726                    .collect::<Vec<String>>()
7727                    .join(",")
7728                    .to_string(),
7729            )]),
7730        };
7731    }
7732    if let Some(ref local_var_str) = name__empty {
7733        local_var_req_builder =
7734            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
7735    }
7736    if let Some(ref local_var_str) = name__ic {
7737        local_var_req_builder = match "multi" {
7738            "multi" => local_var_req_builder.query(
7739                &local_var_str
7740                    .into_iter()
7741                    .map(|p| ("name__ic".to_owned(), p.to_string()))
7742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7743            ),
7744            _ => local_var_req_builder.query(&[(
7745                "name__ic",
7746                &local_var_str
7747                    .into_iter()
7748                    .map(|p| p.to_string())
7749                    .collect::<Vec<String>>()
7750                    .join(",")
7751                    .to_string(),
7752            )]),
7753        };
7754    }
7755    if let Some(ref local_var_str) = name__ie {
7756        local_var_req_builder = match "multi" {
7757            "multi" => local_var_req_builder.query(
7758                &local_var_str
7759                    .into_iter()
7760                    .map(|p| ("name__ie".to_owned(), p.to_string()))
7761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7762            ),
7763            _ => local_var_req_builder.query(&[(
7764                "name__ie",
7765                &local_var_str
7766                    .into_iter()
7767                    .map(|p| p.to_string())
7768                    .collect::<Vec<String>>()
7769                    .join(",")
7770                    .to_string(),
7771            )]),
7772        };
7773    }
7774    if let Some(ref local_var_str) = name__iew {
7775        local_var_req_builder = match "multi" {
7776            "multi" => local_var_req_builder.query(
7777                &local_var_str
7778                    .into_iter()
7779                    .map(|p| ("name__iew".to_owned(), p.to_string()))
7780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7781            ),
7782            _ => local_var_req_builder.query(&[(
7783                "name__iew",
7784                &local_var_str
7785                    .into_iter()
7786                    .map(|p| p.to_string())
7787                    .collect::<Vec<String>>()
7788                    .join(",")
7789                    .to_string(),
7790            )]),
7791        };
7792    }
7793    if let Some(ref local_var_str) = name__iregex {
7794        local_var_req_builder = match "multi" {
7795            "multi" => local_var_req_builder.query(
7796                &local_var_str
7797                    .into_iter()
7798                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
7799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7800            ),
7801            _ => local_var_req_builder.query(&[(
7802                "name__iregex",
7803                &local_var_str
7804                    .into_iter()
7805                    .map(|p| p.to_string())
7806                    .collect::<Vec<String>>()
7807                    .join(",")
7808                    .to_string(),
7809            )]),
7810        };
7811    }
7812    if let Some(ref local_var_str) = name__isw {
7813        local_var_req_builder = match "multi" {
7814            "multi" => local_var_req_builder.query(
7815                &local_var_str
7816                    .into_iter()
7817                    .map(|p| ("name__isw".to_owned(), p.to_string()))
7818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7819            ),
7820            _ => local_var_req_builder.query(&[(
7821                "name__isw",
7822                &local_var_str
7823                    .into_iter()
7824                    .map(|p| p.to_string())
7825                    .collect::<Vec<String>>()
7826                    .join(",")
7827                    .to_string(),
7828            )]),
7829        };
7830    }
7831    if let Some(ref local_var_str) = name__n {
7832        local_var_req_builder = match "multi" {
7833            "multi" => local_var_req_builder.query(
7834                &local_var_str
7835                    .into_iter()
7836                    .map(|p| ("name__n".to_owned(), p.to_string()))
7837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7838            ),
7839            _ => local_var_req_builder.query(&[(
7840                "name__n",
7841                &local_var_str
7842                    .into_iter()
7843                    .map(|p| p.to_string())
7844                    .collect::<Vec<String>>()
7845                    .join(",")
7846                    .to_string(),
7847            )]),
7848        };
7849    }
7850    if let Some(ref local_var_str) = name__nic {
7851        local_var_req_builder = match "multi" {
7852            "multi" => local_var_req_builder.query(
7853                &local_var_str
7854                    .into_iter()
7855                    .map(|p| ("name__nic".to_owned(), p.to_string()))
7856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7857            ),
7858            _ => local_var_req_builder.query(&[(
7859                "name__nic",
7860                &local_var_str
7861                    .into_iter()
7862                    .map(|p| p.to_string())
7863                    .collect::<Vec<String>>()
7864                    .join(",")
7865                    .to_string(),
7866            )]),
7867        };
7868    }
7869    if let Some(ref local_var_str) = name__nie {
7870        local_var_req_builder = match "multi" {
7871            "multi" => local_var_req_builder.query(
7872                &local_var_str
7873                    .into_iter()
7874                    .map(|p| ("name__nie".to_owned(), p.to_string()))
7875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7876            ),
7877            _ => local_var_req_builder.query(&[(
7878                "name__nie",
7879                &local_var_str
7880                    .into_iter()
7881                    .map(|p| p.to_string())
7882                    .collect::<Vec<String>>()
7883                    .join(",")
7884                    .to_string(),
7885            )]),
7886        };
7887    }
7888    if let Some(ref local_var_str) = name__niew {
7889        local_var_req_builder = match "multi" {
7890            "multi" => local_var_req_builder.query(
7891                &local_var_str
7892                    .into_iter()
7893                    .map(|p| ("name__niew".to_owned(), p.to_string()))
7894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7895            ),
7896            _ => local_var_req_builder.query(&[(
7897                "name__niew",
7898                &local_var_str
7899                    .into_iter()
7900                    .map(|p| p.to_string())
7901                    .collect::<Vec<String>>()
7902                    .join(",")
7903                    .to_string(),
7904            )]),
7905        };
7906    }
7907    if let Some(ref local_var_str) = name__nisw {
7908        local_var_req_builder = match "multi" {
7909            "multi" => local_var_req_builder.query(
7910                &local_var_str
7911                    .into_iter()
7912                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
7913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7914            ),
7915            _ => local_var_req_builder.query(&[(
7916                "name__nisw",
7917                &local_var_str
7918                    .into_iter()
7919                    .map(|p| p.to_string())
7920                    .collect::<Vec<String>>()
7921                    .join(",")
7922                    .to_string(),
7923            )]),
7924        };
7925    }
7926    if let Some(ref local_var_str) = name__regex {
7927        local_var_req_builder = match "multi" {
7928            "multi" => local_var_req_builder.query(
7929                &local_var_str
7930                    .into_iter()
7931                    .map(|p| ("name__regex".to_owned(), p.to_string()))
7932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7933            ),
7934            _ => local_var_req_builder.query(&[(
7935                "name__regex",
7936                &local_var_str
7937                    .into_iter()
7938                    .map(|p| p.to_string())
7939                    .collect::<Vec<String>>()
7940                    .join(",")
7941                    .to_string(),
7942            )]),
7943        };
7944    }
7945    if let Some(ref local_var_str) = offset {
7946        local_var_req_builder =
7947            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7948    }
7949    if let Some(ref local_var_str) = ordering {
7950        local_var_req_builder =
7951            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
7952    }
7953    if let Some(ref local_var_str) = owner {
7954        local_var_req_builder = match "multi" {
7955            "multi" => local_var_req_builder.query(
7956                &local_var_str
7957                    .into_iter()
7958                    .map(|p| ("owner".to_owned(), p.to_string()))
7959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7960            ),
7961            _ => local_var_req_builder.query(&[(
7962                "owner",
7963                &local_var_str
7964                    .into_iter()
7965                    .map(|p| p.to_string())
7966                    .collect::<Vec<String>>()
7967                    .join(",")
7968                    .to_string(),
7969            )]),
7970        };
7971    }
7972    if let Some(ref local_var_str) = owner__n {
7973        local_var_req_builder = match "multi" {
7974            "multi" => local_var_req_builder.query(
7975                &local_var_str
7976                    .into_iter()
7977                    .map(|p| ("owner__n".to_owned(), p.to_string()))
7978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7979            ),
7980            _ => local_var_req_builder.query(&[(
7981                "owner__n",
7982                &local_var_str
7983                    .into_iter()
7984                    .map(|p| p.to_string())
7985                    .collect::<Vec<String>>()
7986                    .join(",")
7987                    .to_string(),
7988            )]),
7989        };
7990    }
7991    if let Some(ref local_var_str) = owner_group {
7992        local_var_req_builder = match "multi" {
7993            "multi" => local_var_req_builder.query(
7994                &local_var_str
7995                    .into_iter()
7996                    .map(|p| ("owner_group".to_owned(), p.to_string()))
7997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7998            ),
7999            _ => local_var_req_builder.query(&[(
8000                "owner_group",
8001                &local_var_str
8002                    .into_iter()
8003                    .map(|p| p.to_string())
8004                    .collect::<Vec<String>>()
8005                    .join(",")
8006                    .to_string(),
8007            )]),
8008        };
8009    }
8010    if let Some(ref local_var_str) = owner_group__n {
8011        local_var_req_builder = match "multi" {
8012            "multi" => local_var_req_builder.query(
8013                &local_var_str
8014                    .into_iter()
8015                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
8016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8017            ),
8018            _ => local_var_req_builder.query(&[(
8019                "owner_group__n",
8020                &local_var_str
8021                    .into_iter()
8022                    .map(|p| p.to_string())
8023                    .collect::<Vec<String>>()
8024                    .join(",")
8025                    .to_string(),
8026            )]),
8027        };
8028    }
8029    if let Some(ref local_var_str) = owner_group_id {
8030        local_var_req_builder = match "multi" {
8031            "multi" => local_var_req_builder.query(
8032                &local_var_str
8033                    .into_iter()
8034                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
8035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8036            ),
8037            _ => local_var_req_builder.query(&[(
8038                "owner_group_id",
8039                &local_var_str
8040                    .into_iter()
8041                    .map(|p| p.to_string())
8042                    .collect::<Vec<String>>()
8043                    .join(",")
8044                    .to_string(),
8045            )]),
8046        };
8047    }
8048    if let Some(ref local_var_str) = owner_group_id__n {
8049        local_var_req_builder = match "multi" {
8050            "multi" => local_var_req_builder.query(
8051                &local_var_str
8052                    .into_iter()
8053                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
8054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8055            ),
8056            _ => local_var_req_builder.query(&[(
8057                "owner_group_id__n",
8058                &local_var_str
8059                    .into_iter()
8060                    .map(|p| p.to_string())
8061                    .collect::<Vec<String>>()
8062                    .join(",")
8063                    .to_string(),
8064            )]),
8065        };
8066    }
8067    if let Some(ref local_var_str) = owner_id {
8068        local_var_req_builder = match "multi" {
8069            "multi" => local_var_req_builder.query(
8070                &local_var_str
8071                    .into_iter()
8072                    .map(|p| ("owner_id".to_owned(), p.to_string()))
8073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8074            ),
8075            _ => local_var_req_builder.query(&[(
8076                "owner_id",
8077                &local_var_str
8078                    .into_iter()
8079                    .map(|p| p.to_string())
8080                    .collect::<Vec<String>>()
8081                    .join(",")
8082                    .to_string(),
8083            )]),
8084        };
8085    }
8086    if let Some(ref local_var_str) = owner_id__n {
8087        local_var_req_builder = match "multi" {
8088            "multi" => local_var_req_builder.query(
8089                &local_var_str
8090                    .into_iter()
8091                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
8092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8093            ),
8094            _ => local_var_req_builder.query(&[(
8095                "owner_id__n",
8096                &local_var_str
8097                    .into_iter()
8098                    .map(|p| p.to_string())
8099                    .collect::<Vec<String>>()
8100                    .join(",")
8101                    .to_string(),
8102            )]),
8103        };
8104    }
8105    if let Some(ref local_var_str) = phone {
8106        local_var_req_builder = match "multi" {
8107            "multi" => local_var_req_builder.query(
8108                &local_var_str
8109                    .into_iter()
8110                    .map(|p| ("phone".to_owned(), p.to_string()))
8111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8112            ),
8113            _ => local_var_req_builder.query(&[(
8114                "phone",
8115                &local_var_str
8116                    .into_iter()
8117                    .map(|p| p.to_string())
8118                    .collect::<Vec<String>>()
8119                    .join(",")
8120                    .to_string(),
8121            )]),
8122        };
8123    }
8124    if let Some(ref local_var_str) = phone__empty {
8125        local_var_req_builder =
8126            local_var_req_builder.query(&[("phone__empty", &local_var_str.to_string())]);
8127    }
8128    if let Some(ref local_var_str) = phone__ic {
8129        local_var_req_builder = match "multi" {
8130            "multi" => local_var_req_builder.query(
8131                &local_var_str
8132                    .into_iter()
8133                    .map(|p| ("phone__ic".to_owned(), p.to_string()))
8134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8135            ),
8136            _ => local_var_req_builder.query(&[(
8137                "phone__ic",
8138                &local_var_str
8139                    .into_iter()
8140                    .map(|p| p.to_string())
8141                    .collect::<Vec<String>>()
8142                    .join(",")
8143                    .to_string(),
8144            )]),
8145        };
8146    }
8147    if let Some(ref local_var_str) = phone__ie {
8148        local_var_req_builder = match "multi" {
8149            "multi" => local_var_req_builder.query(
8150                &local_var_str
8151                    .into_iter()
8152                    .map(|p| ("phone__ie".to_owned(), p.to_string()))
8153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8154            ),
8155            _ => local_var_req_builder.query(&[(
8156                "phone__ie",
8157                &local_var_str
8158                    .into_iter()
8159                    .map(|p| p.to_string())
8160                    .collect::<Vec<String>>()
8161                    .join(",")
8162                    .to_string(),
8163            )]),
8164        };
8165    }
8166    if let Some(ref local_var_str) = phone__iew {
8167        local_var_req_builder = match "multi" {
8168            "multi" => local_var_req_builder.query(
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| ("phone__iew".to_owned(), p.to_string()))
8172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8173            ),
8174            _ => local_var_req_builder.query(&[(
8175                "phone__iew",
8176                &local_var_str
8177                    .into_iter()
8178                    .map(|p| p.to_string())
8179                    .collect::<Vec<String>>()
8180                    .join(",")
8181                    .to_string(),
8182            )]),
8183        };
8184    }
8185    if let Some(ref local_var_str) = phone__iregex {
8186        local_var_req_builder = match "multi" {
8187            "multi" => local_var_req_builder.query(
8188                &local_var_str
8189                    .into_iter()
8190                    .map(|p| ("phone__iregex".to_owned(), p.to_string()))
8191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8192            ),
8193            _ => local_var_req_builder.query(&[(
8194                "phone__iregex",
8195                &local_var_str
8196                    .into_iter()
8197                    .map(|p| p.to_string())
8198                    .collect::<Vec<String>>()
8199                    .join(",")
8200                    .to_string(),
8201            )]),
8202        };
8203    }
8204    if let Some(ref local_var_str) = phone__isw {
8205        local_var_req_builder = match "multi" {
8206            "multi" => local_var_req_builder.query(
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| ("phone__isw".to_owned(), p.to_string()))
8210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8211            ),
8212            _ => local_var_req_builder.query(&[(
8213                "phone__isw",
8214                &local_var_str
8215                    .into_iter()
8216                    .map(|p| p.to_string())
8217                    .collect::<Vec<String>>()
8218                    .join(",")
8219                    .to_string(),
8220            )]),
8221        };
8222    }
8223    if let Some(ref local_var_str) = phone__n {
8224        local_var_req_builder = match "multi" {
8225            "multi" => local_var_req_builder.query(
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| ("phone__n".to_owned(), p.to_string()))
8229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8230            ),
8231            _ => local_var_req_builder.query(&[(
8232                "phone__n",
8233                &local_var_str
8234                    .into_iter()
8235                    .map(|p| p.to_string())
8236                    .collect::<Vec<String>>()
8237                    .join(",")
8238                    .to_string(),
8239            )]),
8240        };
8241    }
8242    if let Some(ref local_var_str) = phone__nic {
8243        local_var_req_builder = match "multi" {
8244            "multi" => local_var_req_builder.query(
8245                &local_var_str
8246                    .into_iter()
8247                    .map(|p| ("phone__nic".to_owned(), p.to_string()))
8248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8249            ),
8250            _ => local_var_req_builder.query(&[(
8251                "phone__nic",
8252                &local_var_str
8253                    .into_iter()
8254                    .map(|p| p.to_string())
8255                    .collect::<Vec<String>>()
8256                    .join(",")
8257                    .to_string(),
8258            )]),
8259        };
8260    }
8261    if let Some(ref local_var_str) = phone__nie {
8262        local_var_req_builder = match "multi" {
8263            "multi" => local_var_req_builder.query(
8264                &local_var_str
8265                    .into_iter()
8266                    .map(|p| ("phone__nie".to_owned(), p.to_string()))
8267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8268            ),
8269            _ => local_var_req_builder.query(&[(
8270                "phone__nie",
8271                &local_var_str
8272                    .into_iter()
8273                    .map(|p| p.to_string())
8274                    .collect::<Vec<String>>()
8275                    .join(",")
8276                    .to_string(),
8277            )]),
8278        };
8279    }
8280    if let Some(ref local_var_str) = phone__niew {
8281        local_var_req_builder = match "multi" {
8282            "multi" => local_var_req_builder.query(
8283                &local_var_str
8284                    .into_iter()
8285                    .map(|p| ("phone__niew".to_owned(), p.to_string()))
8286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8287            ),
8288            _ => local_var_req_builder.query(&[(
8289                "phone__niew",
8290                &local_var_str
8291                    .into_iter()
8292                    .map(|p| p.to_string())
8293                    .collect::<Vec<String>>()
8294                    .join(",")
8295                    .to_string(),
8296            )]),
8297        };
8298    }
8299    if let Some(ref local_var_str) = phone__nisw {
8300        local_var_req_builder = match "multi" {
8301            "multi" => local_var_req_builder.query(
8302                &local_var_str
8303                    .into_iter()
8304                    .map(|p| ("phone__nisw".to_owned(), p.to_string()))
8305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8306            ),
8307            _ => local_var_req_builder.query(&[(
8308                "phone__nisw",
8309                &local_var_str
8310                    .into_iter()
8311                    .map(|p| p.to_string())
8312                    .collect::<Vec<String>>()
8313                    .join(",")
8314                    .to_string(),
8315            )]),
8316        };
8317    }
8318    if let Some(ref local_var_str) = phone__regex {
8319        local_var_req_builder = match "multi" {
8320            "multi" => local_var_req_builder.query(
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| ("phone__regex".to_owned(), p.to_string()))
8324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8325            ),
8326            _ => local_var_req_builder.query(&[(
8327                "phone__regex",
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| p.to_string())
8331                    .collect::<Vec<String>>()
8332                    .join(",")
8333                    .to_string(),
8334            )]),
8335        };
8336    }
8337    if let Some(ref local_var_str) = q {
8338        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8339    }
8340    if let Some(ref local_var_str) = start {
8341        local_var_req_builder =
8342            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
8343    }
8344    if let Some(ref local_var_str) = tag {
8345        local_var_req_builder = match "multi" {
8346            "multi" => local_var_req_builder.query(
8347                &local_var_str
8348                    .into_iter()
8349                    .map(|p| ("tag".to_owned(), p.to_string()))
8350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8351            ),
8352            _ => local_var_req_builder.query(&[(
8353                "tag",
8354                &local_var_str
8355                    .into_iter()
8356                    .map(|p| p.to_string())
8357                    .collect::<Vec<String>>()
8358                    .join(",")
8359                    .to_string(),
8360            )]),
8361        };
8362    }
8363    if let Some(ref local_var_str) = tag__n {
8364        local_var_req_builder = match "multi" {
8365            "multi" => local_var_req_builder.query(
8366                &local_var_str
8367                    .into_iter()
8368                    .map(|p| ("tag__n".to_owned(), p.to_string()))
8369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8370            ),
8371            _ => local_var_req_builder.query(&[(
8372                "tag__n",
8373                &local_var_str
8374                    .into_iter()
8375                    .map(|p| p.to_string())
8376                    .collect::<Vec<String>>()
8377                    .join(",")
8378                    .to_string(),
8379            )]),
8380        };
8381    }
8382    if let Some(ref local_var_str) = tag_id {
8383        local_var_req_builder = match "multi" {
8384            "multi" => local_var_req_builder.query(
8385                &local_var_str
8386                    .into_iter()
8387                    .map(|p| ("tag_id".to_owned(), p.to_string()))
8388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8389            ),
8390            _ => local_var_req_builder.query(&[(
8391                "tag_id",
8392                &local_var_str
8393                    .into_iter()
8394                    .map(|p| p.to_string())
8395                    .collect::<Vec<String>>()
8396                    .join(",")
8397                    .to_string(),
8398            )]),
8399        };
8400    }
8401    if let Some(ref local_var_str) = tag_id__n {
8402        local_var_req_builder = match "multi" {
8403            "multi" => local_var_req_builder.query(
8404                &local_var_str
8405                    .into_iter()
8406                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
8407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8408            ),
8409            _ => local_var_req_builder.query(&[(
8410                "tag_id__n",
8411                &local_var_str
8412                    .into_iter()
8413                    .map(|p| p.to_string())
8414                    .collect::<Vec<String>>()
8415                    .join(",")
8416                    .to_string(),
8417            )]),
8418        };
8419    }
8420    if let Some(ref local_var_str) = title {
8421        local_var_req_builder = match "multi" {
8422            "multi" => local_var_req_builder.query(
8423                &local_var_str
8424                    .into_iter()
8425                    .map(|p| ("title".to_owned(), p.to_string()))
8426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8427            ),
8428            _ => local_var_req_builder.query(&[(
8429                "title",
8430                &local_var_str
8431                    .into_iter()
8432                    .map(|p| p.to_string())
8433                    .collect::<Vec<String>>()
8434                    .join(",")
8435                    .to_string(),
8436            )]),
8437        };
8438    }
8439    if let Some(ref local_var_str) = title__empty {
8440        local_var_req_builder =
8441            local_var_req_builder.query(&[("title__empty", &local_var_str.to_string())]);
8442    }
8443    if let Some(ref local_var_str) = title__ic {
8444        local_var_req_builder = match "multi" {
8445            "multi" => local_var_req_builder.query(
8446                &local_var_str
8447                    .into_iter()
8448                    .map(|p| ("title__ic".to_owned(), p.to_string()))
8449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8450            ),
8451            _ => local_var_req_builder.query(&[(
8452                "title__ic",
8453                &local_var_str
8454                    .into_iter()
8455                    .map(|p| p.to_string())
8456                    .collect::<Vec<String>>()
8457                    .join(",")
8458                    .to_string(),
8459            )]),
8460        };
8461    }
8462    if let Some(ref local_var_str) = title__ie {
8463        local_var_req_builder = match "multi" {
8464            "multi" => local_var_req_builder.query(
8465                &local_var_str
8466                    .into_iter()
8467                    .map(|p| ("title__ie".to_owned(), p.to_string()))
8468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8469            ),
8470            _ => local_var_req_builder.query(&[(
8471                "title__ie",
8472                &local_var_str
8473                    .into_iter()
8474                    .map(|p| p.to_string())
8475                    .collect::<Vec<String>>()
8476                    .join(",")
8477                    .to_string(),
8478            )]),
8479        };
8480    }
8481    if let Some(ref local_var_str) = title__iew {
8482        local_var_req_builder = match "multi" {
8483            "multi" => local_var_req_builder.query(
8484                &local_var_str
8485                    .into_iter()
8486                    .map(|p| ("title__iew".to_owned(), p.to_string()))
8487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8488            ),
8489            _ => local_var_req_builder.query(&[(
8490                "title__iew",
8491                &local_var_str
8492                    .into_iter()
8493                    .map(|p| p.to_string())
8494                    .collect::<Vec<String>>()
8495                    .join(",")
8496                    .to_string(),
8497            )]),
8498        };
8499    }
8500    if let Some(ref local_var_str) = title__iregex {
8501        local_var_req_builder = match "multi" {
8502            "multi" => local_var_req_builder.query(
8503                &local_var_str
8504                    .into_iter()
8505                    .map(|p| ("title__iregex".to_owned(), p.to_string()))
8506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8507            ),
8508            _ => local_var_req_builder.query(&[(
8509                "title__iregex",
8510                &local_var_str
8511                    .into_iter()
8512                    .map(|p| p.to_string())
8513                    .collect::<Vec<String>>()
8514                    .join(",")
8515                    .to_string(),
8516            )]),
8517        };
8518    }
8519    if let Some(ref local_var_str) = title__isw {
8520        local_var_req_builder = match "multi" {
8521            "multi" => local_var_req_builder.query(
8522                &local_var_str
8523                    .into_iter()
8524                    .map(|p| ("title__isw".to_owned(), p.to_string()))
8525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8526            ),
8527            _ => local_var_req_builder.query(&[(
8528                "title__isw",
8529                &local_var_str
8530                    .into_iter()
8531                    .map(|p| p.to_string())
8532                    .collect::<Vec<String>>()
8533                    .join(",")
8534                    .to_string(),
8535            )]),
8536        };
8537    }
8538    if let Some(ref local_var_str) = title__n {
8539        local_var_req_builder = match "multi" {
8540            "multi" => local_var_req_builder.query(
8541                &local_var_str
8542                    .into_iter()
8543                    .map(|p| ("title__n".to_owned(), p.to_string()))
8544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8545            ),
8546            _ => local_var_req_builder.query(&[(
8547                "title__n",
8548                &local_var_str
8549                    .into_iter()
8550                    .map(|p| p.to_string())
8551                    .collect::<Vec<String>>()
8552                    .join(",")
8553                    .to_string(),
8554            )]),
8555        };
8556    }
8557    if let Some(ref local_var_str) = title__nic {
8558        local_var_req_builder = match "multi" {
8559            "multi" => local_var_req_builder.query(
8560                &local_var_str
8561                    .into_iter()
8562                    .map(|p| ("title__nic".to_owned(), p.to_string()))
8563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8564            ),
8565            _ => local_var_req_builder.query(&[(
8566                "title__nic",
8567                &local_var_str
8568                    .into_iter()
8569                    .map(|p| p.to_string())
8570                    .collect::<Vec<String>>()
8571                    .join(",")
8572                    .to_string(),
8573            )]),
8574        };
8575    }
8576    if let Some(ref local_var_str) = title__nie {
8577        local_var_req_builder = match "multi" {
8578            "multi" => local_var_req_builder.query(
8579                &local_var_str
8580                    .into_iter()
8581                    .map(|p| ("title__nie".to_owned(), p.to_string()))
8582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8583            ),
8584            _ => local_var_req_builder.query(&[(
8585                "title__nie",
8586                &local_var_str
8587                    .into_iter()
8588                    .map(|p| p.to_string())
8589                    .collect::<Vec<String>>()
8590                    .join(",")
8591                    .to_string(),
8592            )]),
8593        };
8594    }
8595    if let Some(ref local_var_str) = title__niew {
8596        local_var_req_builder = match "multi" {
8597            "multi" => local_var_req_builder.query(
8598                &local_var_str
8599                    .into_iter()
8600                    .map(|p| ("title__niew".to_owned(), p.to_string()))
8601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8602            ),
8603            _ => local_var_req_builder.query(&[(
8604                "title__niew",
8605                &local_var_str
8606                    .into_iter()
8607                    .map(|p| p.to_string())
8608                    .collect::<Vec<String>>()
8609                    .join(",")
8610                    .to_string(),
8611            )]),
8612        };
8613    }
8614    if let Some(ref local_var_str) = title__nisw {
8615        local_var_req_builder = match "multi" {
8616            "multi" => local_var_req_builder.query(
8617                &local_var_str
8618                    .into_iter()
8619                    .map(|p| ("title__nisw".to_owned(), p.to_string()))
8620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8621            ),
8622            _ => local_var_req_builder.query(&[(
8623                "title__nisw",
8624                &local_var_str
8625                    .into_iter()
8626                    .map(|p| p.to_string())
8627                    .collect::<Vec<String>>()
8628                    .join(",")
8629                    .to_string(),
8630            )]),
8631        };
8632    }
8633    if let Some(ref local_var_str) = title__regex {
8634        local_var_req_builder = match "multi" {
8635            "multi" => local_var_req_builder.query(
8636                &local_var_str
8637                    .into_iter()
8638                    .map(|p| ("title__regex".to_owned(), p.to_string()))
8639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8640            ),
8641            _ => local_var_req_builder.query(&[(
8642                "title__regex",
8643                &local_var_str
8644                    .into_iter()
8645                    .map(|p| p.to_string())
8646                    .collect::<Vec<String>>()
8647                    .join(",")
8648                    .to_string(),
8649            )]),
8650        };
8651    }
8652    if let Some(ref local_var_str) = updated_by_request {
8653        local_var_req_builder =
8654            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
8655    }
8656    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8657        local_var_req_builder =
8658            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8659    }
8660    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8661        let local_var_key = local_var_apikey.key.clone();
8662        let local_var_value = match local_var_apikey.prefix {
8663            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8664            None => local_var_key,
8665        };
8666        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8667    };
8668
8669    let local_var_req = local_var_req_builder.build()?;
8670    let local_var_resp = local_var_client.execute(local_var_req).await?;
8671
8672    let local_var_status = local_var_resp.status();
8673    let local_var_content = local_var_resp.text().await?;
8674
8675    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8676        serde_json::from_str(&local_var_content).map_err(Error::from)
8677    } else {
8678        let local_var_entity: Option<TenancyContactsListError> =
8679            serde_json::from_str(&local_var_content).ok();
8680        let local_var_error = ResponseContent {
8681            status: local_var_status,
8682            content: local_var_content,
8683            entity: local_var_entity,
8684        };
8685        Err(Error::ResponseError(local_var_error))
8686    }
8687}
8688
8689/// Patch a contact object.
8690pub async fn tenancy_contacts_partial_update(
8691    configuration: &configuration::Configuration,
8692    id: i32,
8693    patched_contact_request: Option<crate::models::PatchedContactRequest>,
8694) -> Result<crate::models::Contact, Error<TenancyContactsPartialUpdateError>> {
8695    let local_var_configuration = configuration;
8696
8697    let local_var_client = &local_var_configuration.client;
8698
8699    let local_var_uri_str = format!(
8700        "{}/api/tenancy/contacts/{id}/",
8701        local_var_configuration.base_path,
8702        id = id
8703    );
8704    let mut local_var_req_builder =
8705        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8706
8707    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8708        local_var_req_builder =
8709            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8710    }
8711    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8712        let local_var_key = local_var_apikey.key.clone();
8713        let local_var_value = match local_var_apikey.prefix {
8714            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8715            None => local_var_key,
8716        };
8717        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8718    };
8719    local_var_req_builder = local_var_req_builder.json(&patched_contact_request);
8720
8721    let local_var_req = local_var_req_builder.build()?;
8722    let local_var_resp = local_var_client.execute(local_var_req).await?;
8723
8724    let local_var_status = local_var_resp.status();
8725    let local_var_content = local_var_resp.text().await?;
8726
8727    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8728        serde_json::from_str(&local_var_content).map_err(Error::from)
8729    } else {
8730        let local_var_entity: Option<TenancyContactsPartialUpdateError> =
8731            serde_json::from_str(&local_var_content).ok();
8732        let local_var_error = ResponseContent {
8733            status: local_var_status,
8734            content: local_var_content,
8735            entity: local_var_entity,
8736        };
8737        Err(Error::ResponseError(local_var_error))
8738    }
8739}
8740
8741/// Get a contact object.
8742pub async fn tenancy_contacts_retrieve(
8743    configuration: &configuration::Configuration,
8744    id: i32,
8745) -> Result<crate::models::Contact, Error<TenancyContactsRetrieveError>> {
8746    let local_var_configuration = configuration;
8747
8748    let local_var_client = &local_var_configuration.client;
8749
8750    let local_var_uri_str = format!(
8751        "{}/api/tenancy/contacts/{id}/",
8752        local_var_configuration.base_path,
8753        id = id
8754    );
8755    let mut local_var_req_builder =
8756        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8757
8758    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8759        local_var_req_builder =
8760            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8761    }
8762    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8763        let local_var_key = local_var_apikey.key.clone();
8764        let local_var_value = match local_var_apikey.prefix {
8765            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8766            None => local_var_key,
8767        };
8768        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8769    };
8770
8771    let local_var_req = local_var_req_builder.build()?;
8772    let local_var_resp = local_var_client.execute(local_var_req).await?;
8773
8774    let local_var_status = local_var_resp.status();
8775    let local_var_content = local_var_resp.text().await?;
8776
8777    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8778        serde_json::from_str(&local_var_content).map_err(Error::from)
8779    } else {
8780        let local_var_entity: Option<TenancyContactsRetrieveError> =
8781            serde_json::from_str(&local_var_content).ok();
8782        let local_var_error = ResponseContent {
8783            status: local_var_status,
8784            content: local_var_content,
8785            entity: local_var_entity,
8786        };
8787        Err(Error::ResponseError(local_var_error))
8788    }
8789}
8790
8791/// Put a contact object.
8792pub async fn tenancy_contacts_update(
8793    configuration: &configuration::Configuration,
8794    id: i32,
8795    contact_request: crate::models::ContactRequest,
8796) -> Result<crate::models::Contact, Error<TenancyContactsUpdateError>> {
8797    let local_var_configuration = configuration;
8798
8799    let local_var_client = &local_var_configuration.client;
8800
8801    let local_var_uri_str = format!(
8802        "{}/api/tenancy/contacts/{id}/",
8803        local_var_configuration.base_path,
8804        id = id
8805    );
8806    let mut local_var_req_builder =
8807        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8808
8809    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8810        local_var_req_builder =
8811            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8812    }
8813    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8814        let local_var_key = local_var_apikey.key.clone();
8815        let local_var_value = match local_var_apikey.prefix {
8816            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8817            None => local_var_key,
8818        };
8819        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8820    };
8821    local_var_req_builder = local_var_req_builder.json(&contact_request);
8822
8823    let local_var_req = local_var_req_builder.build()?;
8824    let local_var_resp = local_var_client.execute(local_var_req).await?;
8825
8826    let local_var_status = local_var_resp.status();
8827    let local_var_content = local_var_resp.text().await?;
8828
8829    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8830        serde_json::from_str(&local_var_content).map_err(Error::from)
8831    } else {
8832        let local_var_entity: Option<TenancyContactsUpdateError> =
8833            serde_json::from_str(&local_var_content).ok();
8834        let local_var_error = ResponseContent {
8835            status: local_var_status,
8836            content: local_var_content,
8837            entity: local_var_entity,
8838        };
8839        Err(Error::ResponseError(local_var_error))
8840    }
8841}
8842
8843/// Delete a list of tenant group objects.
8844pub async fn tenancy_tenant_groups_bulk_destroy(
8845    configuration: &configuration::Configuration,
8846    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8847) -> Result<(), Error<TenancyTenantGroupsBulkDestroyError>> {
8848    let local_var_configuration = configuration;
8849
8850    let local_var_client = &local_var_configuration.client;
8851
8852    let local_var_uri_str = format!(
8853        "{}/api/tenancy/tenant-groups/",
8854        local_var_configuration.base_path
8855    );
8856    let mut local_var_req_builder =
8857        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8858
8859    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8860        local_var_req_builder =
8861            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8862    }
8863    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8864        let local_var_key = local_var_apikey.key.clone();
8865        let local_var_value = match local_var_apikey.prefix {
8866            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8867            None => local_var_key,
8868        };
8869        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8870    };
8871    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8872
8873    let local_var_req = local_var_req_builder.build()?;
8874    let local_var_resp = local_var_client.execute(local_var_req).await?;
8875
8876    let local_var_status = local_var_resp.status();
8877    let local_var_content = local_var_resp.text().await?;
8878
8879    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8880        Ok(())
8881    } else {
8882        let local_var_entity: Option<TenancyTenantGroupsBulkDestroyError> =
8883            serde_json::from_str(&local_var_content).ok();
8884        let local_var_error = ResponseContent {
8885            status: local_var_status,
8886            content: local_var_content,
8887            entity: local_var_entity,
8888        };
8889        Err(Error::ResponseError(local_var_error))
8890    }
8891}
8892
8893/// Patch a list of tenant group objects.
8894pub async fn tenancy_tenant_groups_bulk_partial_update(
8895    configuration: &configuration::Configuration,
8896    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8897) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkPartialUpdateError>> {
8898    let local_var_configuration = configuration;
8899
8900    let local_var_client = &local_var_configuration.client;
8901
8902    let local_var_uri_str = format!(
8903        "{}/api/tenancy/tenant-groups/",
8904        local_var_configuration.base_path
8905    );
8906    let mut local_var_req_builder =
8907        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8908
8909    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8910        local_var_req_builder =
8911            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8912    }
8913    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8914        let local_var_key = local_var_apikey.key.clone();
8915        let local_var_value = match local_var_apikey.prefix {
8916            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8917            None => local_var_key,
8918        };
8919        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8920    };
8921    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8922
8923    let local_var_req = local_var_req_builder.build()?;
8924    let local_var_resp = local_var_client.execute(local_var_req).await?;
8925
8926    let local_var_status = local_var_resp.status();
8927    let local_var_content = local_var_resp.text().await?;
8928
8929    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8930        serde_json::from_str(&local_var_content).map_err(Error::from)
8931    } else {
8932        let local_var_entity: Option<TenancyTenantGroupsBulkPartialUpdateError> =
8933            serde_json::from_str(&local_var_content).ok();
8934        let local_var_error = ResponseContent {
8935            status: local_var_status,
8936            content: local_var_content,
8937            entity: local_var_entity,
8938        };
8939        Err(Error::ResponseError(local_var_error))
8940    }
8941}
8942
8943/// Put a list of tenant group objects.
8944pub async fn tenancy_tenant_groups_bulk_update(
8945    configuration: &configuration::Configuration,
8946    tenant_group_request: Vec<crate::models::TenantGroupRequest>,
8947) -> Result<Vec<crate::models::TenantGroup>, Error<TenancyTenantGroupsBulkUpdateError>> {
8948    let local_var_configuration = configuration;
8949
8950    let local_var_client = &local_var_configuration.client;
8951
8952    let local_var_uri_str = format!(
8953        "{}/api/tenancy/tenant-groups/",
8954        local_var_configuration.base_path
8955    );
8956    let mut local_var_req_builder =
8957        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8958
8959    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8960        local_var_req_builder =
8961            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8962    }
8963    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8964        let local_var_key = local_var_apikey.key.clone();
8965        let local_var_value = match local_var_apikey.prefix {
8966            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8967            None => local_var_key,
8968        };
8969        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8970    };
8971    local_var_req_builder = local_var_req_builder.json(&tenant_group_request);
8972
8973    let local_var_req = local_var_req_builder.build()?;
8974    let local_var_resp = local_var_client.execute(local_var_req).await?;
8975
8976    let local_var_status = local_var_resp.status();
8977    let local_var_content = local_var_resp.text().await?;
8978
8979    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8980        serde_json::from_str(&local_var_content).map_err(Error::from)
8981    } else {
8982        let local_var_entity: Option<TenancyTenantGroupsBulkUpdateError> =
8983            serde_json::from_str(&local_var_content).ok();
8984        let local_var_error = ResponseContent {
8985            status: local_var_status,
8986            content: local_var_content,
8987            entity: local_var_entity,
8988        };
8989        Err(Error::ResponseError(local_var_error))
8990    }
8991}
8992
8993/// Post a list of tenant group objects.
8994pub async fn tenancy_tenant_groups_create(
8995    configuration: &configuration::Configuration,
8996    tenancy_tenant_groups_create_request: crate::models::TenancyTenantGroupsCreateRequest,
8997) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsCreateError>> {
8998    let local_var_configuration = configuration;
8999
9000    let local_var_client = &local_var_configuration.client;
9001
9002    let local_var_uri_str = format!(
9003        "{}/api/tenancy/tenant-groups/",
9004        local_var_configuration.base_path
9005    );
9006    let mut local_var_req_builder =
9007        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9008
9009    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9010        local_var_req_builder =
9011            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9012    }
9013    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9014        let local_var_key = local_var_apikey.key.clone();
9015        let local_var_value = match local_var_apikey.prefix {
9016            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9017            None => local_var_key,
9018        };
9019        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9020    };
9021    local_var_req_builder = local_var_req_builder.json(&tenancy_tenant_groups_create_request);
9022
9023    let local_var_req = local_var_req_builder.build()?;
9024    let local_var_resp = local_var_client.execute(local_var_req).await?;
9025
9026    let local_var_status = local_var_resp.status();
9027    let local_var_content = local_var_resp.text().await?;
9028
9029    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9030        serde_json::from_str(&local_var_content).map_err(Error::from)
9031    } else {
9032        let local_var_entity: Option<TenancyTenantGroupsCreateError> =
9033            serde_json::from_str(&local_var_content).ok();
9034        let local_var_error = ResponseContent {
9035            status: local_var_status,
9036            content: local_var_content,
9037            entity: local_var_entity,
9038        };
9039        Err(Error::ResponseError(local_var_error))
9040    }
9041}
9042
9043/// Delete a tenant group object.
9044pub async fn tenancy_tenant_groups_destroy(
9045    configuration: &configuration::Configuration,
9046    id: i32,
9047) -> Result<(), Error<TenancyTenantGroupsDestroyError>> {
9048    let local_var_configuration = configuration;
9049
9050    let local_var_client = &local_var_configuration.client;
9051
9052    let local_var_uri_str = format!(
9053        "{}/api/tenancy/tenant-groups/{id}/",
9054        local_var_configuration.base_path,
9055        id = id
9056    );
9057    let mut local_var_req_builder =
9058        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9059
9060    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9061        local_var_req_builder =
9062            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9063    }
9064    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9065        let local_var_key = local_var_apikey.key.clone();
9066        let local_var_value = match local_var_apikey.prefix {
9067            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9068            None => local_var_key,
9069        };
9070        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9071    };
9072
9073    let local_var_req = local_var_req_builder.build()?;
9074    let local_var_resp = local_var_client.execute(local_var_req).await?;
9075
9076    let local_var_status = local_var_resp.status();
9077    let local_var_content = local_var_resp.text().await?;
9078
9079    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9080        Ok(())
9081    } else {
9082        let local_var_entity: Option<TenancyTenantGroupsDestroyError> =
9083            serde_json::from_str(&local_var_content).ok();
9084        let local_var_error = ResponseContent {
9085            status: local_var_status,
9086            content: local_var_content,
9087            entity: local_var_entity,
9088        };
9089        Err(Error::ResponseError(local_var_error))
9090    }
9091}
9092
9093/// Get a list of tenant group objects.
9094pub async fn tenancy_tenant_groups_list(
9095    configuration: &configuration::Configuration,
9096    ancestor: Option<Vec<String>>,
9097    ancestor__n: Option<Vec<String>>,
9098    ancestor_id: Option<Vec<String>>,
9099    ancestor_id__n: Option<Vec<String>>,
9100    created: Option<Vec<String>>,
9101    created__empty: Option<Vec<String>>,
9102    created__gt: Option<Vec<String>>,
9103    created__gte: Option<Vec<String>>,
9104    created__lt: Option<Vec<String>>,
9105    created__lte: Option<Vec<String>>,
9106    created__n: Option<Vec<String>>,
9107    created_by_request: Option<&str>,
9108    description: Option<Vec<String>>,
9109    description__empty: Option<bool>,
9110    description__ic: Option<Vec<String>>,
9111    description__ie: Option<Vec<String>>,
9112    description__iew: Option<Vec<String>>,
9113    description__iregex: Option<Vec<String>>,
9114    description__isw: Option<Vec<String>>,
9115    description__n: Option<Vec<String>>,
9116    description__nic: Option<Vec<String>>,
9117    description__nie: Option<Vec<String>>,
9118    description__niew: Option<Vec<String>>,
9119    description__nisw: Option<Vec<String>>,
9120    description__regex: Option<Vec<String>>,
9121    id: Option<Vec<i32>>,
9122    id__empty: Option<bool>,
9123    id__gt: Option<Vec<i32>>,
9124    id__gte: Option<Vec<i32>>,
9125    id__lt: Option<Vec<i32>>,
9126    id__lte: Option<Vec<i32>>,
9127    id__n: Option<Vec<i32>>,
9128    last_updated: Option<Vec<String>>,
9129    last_updated__empty: Option<Vec<String>>,
9130    last_updated__gt: Option<Vec<String>>,
9131    last_updated__gte: Option<Vec<String>>,
9132    last_updated__lt: Option<Vec<String>>,
9133    last_updated__lte: Option<Vec<String>>,
9134    last_updated__n: Option<Vec<String>>,
9135    limit: Option<i32>,
9136    modified_by_request: Option<&str>,
9137    name: Option<Vec<String>>,
9138    name__empty: Option<bool>,
9139    name__ic: Option<Vec<String>>,
9140    name__ie: Option<Vec<String>>,
9141    name__iew: Option<Vec<String>>,
9142    name__iregex: Option<Vec<String>>,
9143    name__isw: Option<Vec<String>>,
9144    name__n: Option<Vec<String>>,
9145    name__nic: Option<Vec<String>>,
9146    name__nie: Option<Vec<String>>,
9147    name__niew: Option<Vec<String>>,
9148    name__nisw: Option<Vec<String>>,
9149    name__regex: Option<Vec<String>>,
9150    offset: Option<i32>,
9151    ordering: Option<&str>,
9152    owner: Option<Vec<String>>,
9153    owner__n: Option<Vec<String>>,
9154    owner_group: Option<Vec<String>>,
9155    owner_group__n: Option<Vec<String>>,
9156    owner_group_id: Option<Vec<i32>>,
9157    owner_group_id__n: Option<Vec<i32>>,
9158    owner_id: Option<Vec<i32>>,
9159    owner_id__n: Option<Vec<i32>>,
9160    parent: Option<Vec<String>>,
9161    parent__n: Option<Vec<String>>,
9162    parent_id: Option<Vec<i32>>,
9163    parent_id__n: Option<Vec<i32>>,
9164    q: Option<&str>,
9165    slug: Option<Vec<String>>,
9166    slug__empty: Option<bool>,
9167    slug__ic: Option<Vec<String>>,
9168    slug__ie: Option<Vec<String>>,
9169    slug__iew: Option<Vec<String>>,
9170    slug__iregex: Option<Vec<String>>,
9171    slug__isw: Option<Vec<String>>,
9172    slug__n: Option<Vec<String>>,
9173    slug__nic: Option<Vec<String>>,
9174    slug__nie: Option<Vec<String>>,
9175    slug__niew: Option<Vec<String>>,
9176    slug__nisw: Option<Vec<String>>,
9177    slug__regex: Option<Vec<String>>,
9178    start: Option<i32>,
9179    tag: Option<Vec<String>>,
9180    tag__n: Option<Vec<String>>,
9181    tag_id: Option<Vec<i32>>,
9182    tag_id__n: Option<Vec<i32>>,
9183    updated_by_request: Option<&str>,
9184) -> Result<crate::models::PaginatedTenantGroupList, Error<TenancyTenantGroupsListError>> {
9185    let local_var_configuration = configuration;
9186
9187    let local_var_client = &local_var_configuration.client;
9188
9189    let local_var_uri_str = format!(
9190        "{}/api/tenancy/tenant-groups/",
9191        local_var_configuration.base_path
9192    );
9193    let mut local_var_req_builder =
9194        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9195
9196    if let Some(ref local_var_str) = ancestor {
9197        local_var_req_builder = match "multi" {
9198            "multi" => local_var_req_builder.query(
9199                &local_var_str
9200                    .into_iter()
9201                    .map(|p| ("ancestor".to_owned(), p.to_string()))
9202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9203            ),
9204            _ => local_var_req_builder.query(&[(
9205                "ancestor",
9206                &local_var_str
9207                    .into_iter()
9208                    .map(|p| p.to_string())
9209                    .collect::<Vec<String>>()
9210                    .join(",")
9211                    .to_string(),
9212            )]),
9213        };
9214    }
9215    if let Some(ref local_var_str) = ancestor__n {
9216        local_var_req_builder = match "multi" {
9217            "multi" => local_var_req_builder.query(
9218                &local_var_str
9219                    .into_iter()
9220                    .map(|p| ("ancestor__n".to_owned(), p.to_string()))
9221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9222            ),
9223            _ => local_var_req_builder.query(&[(
9224                "ancestor__n",
9225                &local_var_str
9226                    .into_iter()
9227                    .map(|p| p.to_string())
9228                    .collect::<Vec<String>>()
9229                    .join(",")
9230                    .to_string(),
9231            )]),
9232        };
9233    }
9234    if let Some(ref local_var_str) = ancestor_id {
9235        local_var_req_builder = match "multi" {
9236            "multi" => local_var_req_builder.query(
9237                &local_var_str
9238                    .into_iter()
9239                    .map(|p| ("ancestor_id".to_owned(), p.to_string()))
9240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9241            ),
9242            _ => local_var_req_builder.query(&[(
9243                "ancestor_id",
9244                &local_var_str
9245                    .into_iter()
9246                    .map(|p| p.to_string())
9247                    .collect::<Vec<String>>()
9248                    .join(",")
9249                    .to_string(),
9250            )]),
9251        };
9252    }
9253    if let Some(ref local_var_str) = ancestor_id__n {
9254        local_var_req_builder = match "multi" {
9255            "multi" => local_var_req_builder.query(
9256                &local_var_str
9257                    .into_iter()
9258                    .map(|p| ("ancestor_id__n".to_owned(), p.to_string()))
9259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9260            ),
9261            _ => local_var_req_builder.query(&[(
9262                "ancestor_id__n",
9263                &local_var_str
9264                    .into_iter()
9265                    .map(|p| p.to_string())
9266                    .collect::<Vec<String>>()
9267                    .join(",")
9268                    .to_string(),
9269            )]),
9270        };
9271    }
9272    if let Some(ref local_var_str) = created {
9273        local_var_req_builder = match "multi" {
9274            "multi" => local_var_req_builder.query(
9275                &local_var_str
9276                    .into_iter()
9277                    .map(|p| ("created".to_owned(), p.to_string()))
9278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9279            ),
9280            _ => local_var_req_builder.query(&[(
9281                "created",
9282                &local_var_str
9283                    .into_iter()
9284                    .map(|p| p.to_string())
9285                    .collect::<Vec<String>>()
9286                    .join(",")
9287                    .to_string(),
9288            )]),
9289        };
9290    }
9291    if let Some(ref local_var_str) = created__empty {
9292        local_var_req_builder = match "multi" {
9293            "multi" => local_var_req_builder.query(
9294                &local_var_str
9295                    .into_iter()
9296                    .map(|p| ("created__empty".to_owned(), p.to_string()))
9297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9298            ),
9299            _ => local_var_req_builder.query(&[(
9300                "created__empty",
9301                &local_var_str
9302                    .into_iter()
9303                    .map(|p| p.to_string())
9304                    .collect::<Vec<String>>()
9305                    .join(",")
9306                    .to_string(),
9307            )]),
9308        };
9309    }
9310    if let Some(ref local_var_str) = created__gt {
9311        local_var_req_builder = match "multi" {
9312            "multi" => local_var_req_builder.query(
9313                &local_var_str
9314                    .into_iter()
9315                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9317            ),
9318            _ => local_var_req_builder.query(&[(
9319                "created__gt",
9320                &local_var_str
9321                    .into_iter()
9322                    .map(|p| p.to_string())
9323                    .collect::<Vec<String>>()
9324                    .join(",")
9325                    .to_string(),
9326            )]),
9327        };
9328    }
9329    if let Some(ref local_var_str) = created__gte {
9330        local_var_req_builder = match "multi" {
9331            "multi" => local_var_req_builder.query(
9332                &local_var_str
9333                    .into_iter()
9334                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9336            ),
9337            _ => local_var_req_builder.query(&[(
9338                "created__gte",
9339                &local_var_str
9340                    .into_iter()
9341                    .map(|p| p.to_string())
9342                    .collect::<Vec<String>>()
9343                    .join(",")
9344                    .to_string(),
9345            )]),
9346        };
9347    }
9348    if let Some(ref local_var_str) = created__lt {
9349        local_var_req_builder = match "multi" {
9350            "multi" => local_var_req_builder.query(
9351                &local_var_str
9352                    .into_iter()
9353                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9355            ),
9356            _ => local_var_req_builder.query(&[(
9357                "created__lt",
9358                &local_var_str
9359                    .into_iter()
9360                    .map(|p| p.to_string())
9361                    .collect::<Vec<String>>()
9362                    .join(",")
9363                    .to_string(),
9364            )]),
9365        };
9366    }
9367    if let Some(ref local_var_str) = created__lte {
9368        local_var_req_builder = match "multi" {
9369            "multi" => local_var_req_builder.query(
9370                &local_var_str
9371                    .into_iter()
9372                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9374            ),
9375            _ => local_var_req_builder.query(&[(
9376                "created__lte",
9377                &local_var_str
9378                    .into_iter()
9379                    .map(|p| p.to_string())
9380                    .collect::<Vec<String>>()
9381                    .join(",")
9382                    .to_string(),
9383            )]),
9384        };
9385    }
9386    if let Some(ref local_var_str) = created__n {
9387        local_var_req_builder = match "multi" {
9388            "multi" => local_var_req_builder.query(
9389                &local_var_str
9390                    .into_iter()
9391                    .map(|p| ("created__n".to_owned(), p.to_string()))
9392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9393            ),
9394            _ => local_var_req_builder.query(&[(
9395                "created__n",
9396                &local_var_str
9397                    .into_iter()
9398                    .map(|p| p.to_string())
9399                    .collect::<Vec<String>>()
9400                    .join(",")
9401                    .to_string(),
9402            )]),
9403        };
9404    }
9405    if let Some(ref local_var_str) = created_by_request {
9406        local_var_req_builder =
9407            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
9408    }
9409    if let Some(ref local_var_str) = description {
9410        local_var_req_builder = match "multi" {
9411            "multi" => local_var_req_builder.query(
9412                &local_var_str
9413                    .into_iter()
9414                    .map(|p| ("description".to_owned(), p.to_string()))
9415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9416            ),
9417            _ => local_var_req_builder.query(&[(
9418                "description",
9419                &local_var_str
9420                    .into_iter()
9421                    .map(|p| p.to_string())
9422                    .collect::<Vec<String>>()
9423                    .join(",")
9424                    .to_string(),
9425            )]),
9426        };
9427    }
9428    if let Some(ref local_var_str) = description__empty {
9429        local_var_req_builder =
9430            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
9431    }
9432    if let Some(ref local_var_str) = description__ic {
9433        local_var_req_builder = match "multi" {
9434            "multi" => local_var_req_builder.query(
9435                &local_var_str
9436                    .into_iter()
9437                    .map(|p| ("description__ic".to_owned(), p.to_string()))
9438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9439            ),
9440            _ => local_var_req_builder.query(&[(
9441                "description__ic",
9442                &local_var_str
9443                    .into_iter()
9444                    .map(|p| p.to_string())
9445                    .collect::<Vec<String>>()
9446                    .join(",")
9447                    .to_string(),
9448            )]),
9449        };
9450    }
9451    if let Some(ref local_var_str) = description__ie {
9452        local_var_req_builder = match "multi" {
9453            "multi" => local_var_req_builder.query(
9454                &local_var_str
9455                    .into_iter()
9456                    .map(|p| ("description__ie".to_owned(), p.to_string()))
9457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9458            ),
9459            _ => local_var_req_builder.query(&[(
9460                "description__ie",
9461                &local_var_str
9462                    .into_iter()
9463                    .map(|p| p.to_string())
9464                    .collect::<Vec<String>>()
9465                    .join(",")
9466                    .to_string(),
9467            )]),
9468        };
9469    }
9470    if let Some(ref local_var_str) = description__iew {
9471        local_var_req_builder = match "multi" {
9472            "multi" => local_var_req_builder.query(
9473                &local_var_str
9474                    .into_iter()
9475                    .map(|p| ("description__iew".to_owned(), p.to_string()))
9476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9477            ),
9478            _ => local_var_req_builder.query(&[(
9479                "description__iew",
9480                &local_var_str
9481                    .into_iter()
9482                    .map(|p| p.to_string())
9483                    .collect::<Vec<String>>()
9484                    .join(",")
9485                    .to_string(),
9486            )]),
9487        };
9488    }
9489    if let Some(ref local_var_str) = description__iregex {
9490        local_var_req_builder = match "multi" {
9491            "multi" => local_var_req_builder.query(
9492                &local_var_str
9493                    .into_iter()
9494                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
9495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9496            ),
9497            _ => local_var_req_builder.query(&[(
9498                "description__iregex",
9499                &local_var_str
9500                    .into_iter()
9501                    .map(|p| p.to_string())
9502                    .collect::<Vec<String>>()
9503                    .join(",")
9504                    .to_string(),
9505            )]),
9506        };
9507    }
9508    if let Some(ref local_var_str) = description__isw {
9509        local_var_req_builder = match "multi" {
9510            "multi" => local_var_req_builder.query(
9511                &local_var_str
9512                    .into_iter()
9513                    .map(|p| ("description__isw".to_owned(), p.to_string()))
9514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9515            ),
9516            _ => local_var_req_builder.query(&[(
9517                "description__isw",
9518                &local_var_str
9519                    .into_iter()
9520                    .map(|p| p.to_string())
9521                    .collect::<Vec<String>>()
9522                    .join(",")
9523                    .to_string(),
9524            )]),
9525        };
9526    }
9527    if let Some(ref local_var_str) = description__n {
9528        local_var_req_builder = match "multi" {
9529            "multi" => local_var_req_builder.query(
9530                &local_var_str
9531                    .into_iter()
9532                    .map(|p| ("description__n".to_owned(), p.to_string()))
9533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9534            ),
9535            _ => local_var_req_builder.query(&[(
9536                "description__n",
9537                &local_var_str
9538                    .into_iter()
9539                    .map(|p| p.to_string())
9540                    .collect::<Vec<String>>()
9541                    .join(",")
9542                    .to_string(),
9543            )]),
9544        };
9545    }
9546    if let Some(ref local_var_str) = description__nic {
9547        local_var_req_builder = match "multi" {
9548            "multi" => local_var_req_builder.query(
9549                &local_var_str
9550                    .into_iter()
9551                    .map(|p| ("description__nic".to_owned(), p.to_string()))
9552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9553            ),
9554            _ => local_var_req_builder.query(&[(
9555                "description__nic",
9556                &local_var_str
9557                    .into_iter()
9558                    .map(|p| p.to_string())
9559                    .collect::<Vec<String>>()
9560                    .join(",")
9561                    .to_string(),
9562            )]),
9563        };
9564    }
9565    if let Some(ref local_var_str) = description__nie {
9566        local_var_req_builder = match "multi" {
9567            "multi" => local_var_req_builder.query(
9568                &local_var_str
9569                    .into_iter()
9570                    .map(|p| ("description__nie".to_owned(), p.to_string()))
9571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9572            ),
9573            _ => local_var_req_builder.query(&[(
9574                "description__nie",
9575                &local_var_str
9576                    .into_iter()
9577                    .map(|p| p.to_string())
9578                    .collect::<Vec<String>>()
9579                    .join(",")
9580                    .to_string(),
9581            )]),
9582        };
9583    }
9584    if let Some(ref local_var_str) = description__niew {
9585        local_var_req_builder = match "multi" {
9586            "multi" => local_var_req_builder.query(
9587                &local_var_str
9588                    .into_iter()
9589                    .map(|p| ("description__niew".to_owned(), p.to_string()))
9590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9591            ),
9592            _ => local_var_req_builder.query(&[(
9593                "description__niew",
9594                &local_var_str
9595                    .into_iter()
9596                    .map(|p| p.to_string())
9597                    .collect::<Vec<String>>()
9598                    .join(",")
9599                    .to_string(),
9600            )]),
9601        };
9602    }
9603    if let Some(ref local_var_str) = description__nisw {
9604        local_var_req_builder = match "multi" {
9605            "multi" => local_var_req_builder.query(
9606                &local_var_str
9607                    .into_iter()
9608                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
9609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9610            ),
9611            _ => local_var_req_builder.query(&[(
9612                "description__nisw",
9613                &local_var_str
9614                    .into_iter()
9615                    .map(|p| p.to_string())
9616                    .collect::<Vec<String>>()
9617                    .join(",")
9618                    .to_string(),
9619            )]),
9620        };
9621    }
9622    if let Some(ref local_var_str) = description__regex {
9623        local_var_req_builder = match "multi" {
9624            "multi" => local_var_req_builder.query(
9625                &local_var_str
9626                    .into_iter()
9627                    .map(|p| ("description__regex".to_owned(), p.to_string()))
9628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9629            ),
9630            _ => local_var_req_builder.query(&[(
9631                "description__regex",
9632                &local_var_str
9633                    .into_iter()
9634                    .map(|p| p.to_string())
9635                    .collect::<Vec<String>>()
9636                    .join(",")
9637                    .to_string(),
9638            )]),
9639        };
9640    }
9641    if let Some(ref local_var_str) = id {
9642        local_var_req_builder = match "multi" {
9643            "multi" => local_var_req_builder.query(
9644                &local_var_str
9645                    .into_iter()
9646                    .map(|p| ("id".to_owned(), p.to_string()))
9647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9648            ),
9649            _ => local_var_req_builder.query(&[(
9650                "id",
9651                &local_var_str
9652                    .into_iter()
9653                    .map(|p| p.to_string())
9654                    .collect::<Vec<String>>()
9655                    .join(",")
9656                    .to_string(),
9657            )]),
9658        };
9659    }
9660    if let Some(ref local_var_str) = id__empty {
9661        local_var_req_builder =
9662            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
9663    }
9664    if let Some(ref local_var_str) = id__gt {
9665        local_var_req_builder = match "multi" {
9666            "multi" => local_var_req_builder.query(
9667                &local_var_str
9668                    .into_iter()
9669                    .map(|p| ("id__gt".to_owned(), p.to_string()))
9670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9671            ),
9672            _ => local_var_req_builder.query(&[(
9673                "id__gt",
9674                &local_var_str
9675                    .into_iter()
9676                    .map(|p| p.to_string())
9677                    .collect::<Vec<String>>()
9678                    .join(",")
9679                    .to_string(),
9680            )]),
9681        };
9682    }
9683    if let Some(ref local_var_str) = id__gte {
9684        local_var_req_builder = match "multi" {
9685            "multi" => local_var_req_builder.query(
9686                &local_var_str
9687                    .into_iter()
9688                    .map(|p| ("id__gte".to_owned(), p.to_string()))
9689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9690            ),
9691            _ => local_var_req_builder.query(&[(
9692                "id__gte",
9693                &local_var_str
9694                    .into_iter()
9695                    .map(|p| p.to_string())
9696                    .collect::<Vec<String>>()
9697                    .join(",")
9698                    .to_string(),
9699            )]),
9700        };
9701    }
9702    if let Some(ref local_var_str) = id__lt {
9703        local_var_req_builder = match "multi" {
9704            "multi" => local_var_req_builder.query(
9705                &local_var_str
9706                    .into_iter()
9707                    .map(|p| ("id__lt".to_owned(), p.to_string()))
9708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9709            ),
9710            _ => local_var_req_builder.query(&[(
9711                "id__lt",
9712                &local_var_str
9713                    .into_iter()
9714                    .map(|p| p.to_string())
9715                    .collect::<Vec<String>>()
9716                    .join(",")
9717                    .to_string(),
9718            )]),
9719        };
9720    }
9721    if let Some(ref local_var_str) = id__lte {
9722        local_var_req_builder = match "multi" {
9723            "multi" => local_var_req_builder.query(
9724                &local_var_str
9725                    .into_iter()
9726                    .map(|p| ("id__lte".to_owned(), p.to_string()))
9727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9728            ),
9729            _ => local_var_req_builder.query(&[(
9730                "id__lte",
9731                &local_var_str
9732                    .into_iter()
9733                    .map(|p| p.to_string())
9734                    .collect::<Vec<String>>()
9735                    .join(",")
9736                    .to_string(),
9737            )]),
9738        };
9739    }
9740    if let Some(ref local_var_str) = id__n {
9741        local_var_req_builder = match "multi" {
9742            "multi" => local_var_req_builder.query(
9743                &local_var_str
9744                    .into_iter()
9745                    .map(|p| ("id__n".to_owned(), p.to_string()))
9746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9747            ),
9748            _ => local_var_req_builder.query(&[(
9749                "id__n",
9750                &local_var_str
9751                    .into_iter()
9752                    .map(|p| p.to_string())
9753                    .collect::<Vec<String>>()
9754                    .join(",")
9755                    .to_string(),
9756            )]),
9757        };
9758    }
9759    if let Some(ref local_var_str) = last_updated {
9760        local_var_req_builder = match "multi" {
9761            "multi" => local_var_req_builder.query(
9762                &local_var_str
9763                    .into_iter()
9764                    .map(|p| ("last_updated".to_owned(), p.to_string()))
9765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9766            ),
9767            _ => local_var_req_builder.query(&[(
9768                "last_updated",
9769                &local_var_str
9770                    .into_iter()
9771                    .map(|p| p.to_string())
9772                    .collect::<Vec<String>>()
9773                    .join(",")
9774                    .to_string(),
9775            )]),
9776        };
9777    }
9778    if let Some(ref local_var_str) = last_updated__empty {
9779        local_var_req_builder = match "multi" {
9780            "multi" => local_var_req_builder.query(
9781                &local_var_str
9782                    .into_iter()
9783                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
9784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9785            ),
9786            _ => local_var_req_builder.query(&[(
9787                "last_updated__empty",
9788                &local_var_str
9789                    .into_iter()
9790                    .map(|p| p.to_string())
9791                    .collect::<Vec<String>>()
9792                    .join(",")
9793                    .to_string(),
9794            )]),
9795        };
9796    }
9797    if let Some(ref local_var_str) = last_updated__gt {
9798        local_var_req_builder = match "multi" {
9799            "multi" => local_var_req_builder.query(
9800                &local_var_str
9801                    .into_iter()
9802                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
9803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9804            ),
9805            _ => local_var_req_builder.query(&[(
9806                "last_updated__gt",
9807                &local_var_str
9808                    .into_iter()
9809                    .map(|p| p.to_string())
9810                    .collect::<Vec<String>>()
9811                    .join(",")
9812                    .to_string(),
9813            )]),
9814        };
9815    }
9816    if let Some(ref local_var_str) = last_updated__gte {
9817        local_var_req_builder = match "multi" {
9818            "multi" => local_var_req_builder.query(
9819                &local_var_str
9820                    .into_iter()
9821                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
9822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9823            ),
9824            _ => local_var_req_builder.query(&[(
9825                "last_updated__gte",
9826                &local_var_str
9827                    .into_iter()
9828                    .map(|p| p.to_string())
9829                    .collect::<Vec<String>>()
9830                    .join(",")
9831                    .to_string(),
9832            )]),
9833        };
9834    }
9835    if let Some(ref local_var_str) = last_updated__lt {
9836        local_var_req_builder = match "multi" {
9837            "multi" => local_var_req_builder.query(
9838                &local_var_str
9839                    .into_iter()
9840                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
9841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9842            ),
9843            _ => local_var_req_builder.query(&[(
9844                "last_updated__lt",
9845                &local_var_str
9846                    .into_iter()
9847                    .map(|p| p.to_string())
9848                    .collect::<Vec<String>>()
9849                    .join(",")
9850                    .to_string(),
9851            )]),
9852        };
9853    }
9854    if let Some(ref local_var_str) = last_updated__lte {
9855        local_var_req_builder = match "multi" {
9856            "multi" => local_var_req_builder.query(
9857                &local_var_str
9858                    .into_iter()
9859                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
9860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9861            ),
9862            _ => local_var_req_builder.query(&[(
9863                "last_updated__lte",
9864                &local_var_str
9865                    .into_iter()
9866                    .map(|p| p.to_string())
9867                    .collect::<Vec<String>>()
9868                    .join(",")
9869                    .to_string(),
9870            )]),
9871        };
9872    }
9873    if let Some(ref local_var_str) = last_updated__n {
9874        local_var_req_builder = match "multi" {
9875            "multi" => local_var_req_builder.query(
9876                &local_var_str
9877                    .into_iter()
9878                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
9879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9880            ),
9881            _ => local_var_req_builder.query(&[(
9882                "last_updated__n",
9883                &local_var_str
9884                    .into_iter()
9885                    .map(|p| p.to_string())
9886                    .collect::<Vec<String>>()
9887                    .join(",")
9888                    .to_string(),
9889            )]),
9890        };
9891    }
9892    if let Some(ref local_var_str) = limit {
9893        local_var_req_builder =
9894            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9895    }
9896    if let Some(ref local_var_str) = modified_by_request {
9897        local_var_req_builder =
9898            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
9899    }
9900    if let Some(ref local_var_str) = name {
9901        local_var_req_builder = match "multi" {
9902            "multi" => local_var_req_builder.query(
9903                &local_var_str
9904                    .into_iter()
9905                    .map(|p| ("name".to_owned(), p.to_string()))
9906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9907            ),
9908            _ => local_var_req_builder.query(&[(
9909                "name",
9910                &local_var_str
9911                    .into_iter()
9912                    .map(|p| p.to_string())
9913                    .collect::<Vec<String>>()
9914                    .join(",")
9915                    .to_string(),
9916            )]),
9917        };
9918    }
9919    if let Some(ref local_var_str) = name__empty {
9920        local_var_req_builder =
9921            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
9922    }
9923    if let Some(ref local_var_str) = name__ic {
9924        local_var_req_builder = match "multi" {
9925            "multi" => local_var_req_builder.query(
9926                &local_var_str
9927                    .into_iter()
9928                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9930            ),
9931            _ => local_var_req_builder.query(&[(
9932                "name__ic",
9933                &local_var_str
9934                    .into_iter()
9935                    .map(|p| p.to_string())
9936                    .collect::<Vec<String>>()
9937                    .join(",")
9938                    .to_string(),
9939            )]),
9940        };
9941    }
9942    if let Some(ref local_var_str) = name__ie {
9943        local_var_req_builder = match "multi" {
9944            "multi" => local_var_req_builder.query(
9945                &local_var_str
9946                    .into_iter()
9947                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9949            ),
9950            _ => local_var_req_builder.query(&[(
9951                "name__ie",
9952                &local_var_str
9953                    .into_iter()
9954                    .map(|p| p.to_string())
9955                    .collect::<Vec<String>>()
9956                    .join(",")
9957                    .to_string(),
9958            )]),
9959        };
9960    }
9961    if let Some(ref local_var_str) = name__iew {
9962        local_var_req_builder = match "multi" {
9963            "multi" => local_var_req_builder.query(
9964                &local_var_str
9965                    .into_iter()
9966                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9968            ),
9969            _ => local_var_req_builder.query(&[(
9970                "name__iew",
9971                &local_var_str
9972                    .into_iter()
9973                    .map(|p| p.to_string())
9974                    .collect::<Vec<String>>()
9975                    .join(",")
9976                    .to_string(),
9977            )]),
9978        };
9979    }
9980    if let Some(ref local_var_str) = name__iregex {
9981        local_var_req_builder = match "multi" {
9982            "multi" => local_var_req_builder.query(
9983                &local_var_str
9984                    .into_iter()
9985                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9987            ),
9988            _ => local_var_req_builder.query(&[(
9989                "name__iregex",
9990                &local_var_str
9991                    .into_iter()
9992                    .map(|p| p.to_string())
9993                    .collect::<Vec<String>>()
9994                    .join(",")
9995                    .to_string(),
9996            )]),
9997        };
9998    }
9999    if let Some(ref local_var_str) = name__isw {
10000        local_var_req_builder = match "multi" {
10001            "multi" => local_var_req_builder.query(
10002                &local_var_str
10003                    .into_iter()
10004                    .map(|p| ("name__isw".to_owned(), p.to_string()))
10005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10006            ),
10007            _ => local_var_req_builder.query(&[(
10008                "name__isw",
10009                &local_var_str
10010                    .into_iter()
10011                    .map(|p| p.to_string())
10012                    .collect::<Vec<String>>()
10013                    .join(",")
10014                    .to_string(),
10015            )]),
10016        };
10017    }
10018    if let Some(ref local_var_str) = name__n {
10019        local_var_req_builder = match "multi" {
10020            "multi" => local_var_req_builder.query(
10021                &local_var_str
10022                    .into_iter()
10023                    .map(|p| ("name__n".to_owned(), p.to_string()))
10024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10025            ),
10026            _ => local_var_req_builder.query(&[(
10027                "name__n",
10028                &local_var_str
10029                    .into_iter()
10030                    .map(|p| p.to_string())
10031                    .collect::<Vec<String>>()
10032                    .join(",")
10033                    .to_string(),
10034            )]),
10035        };
10036    }
10037    if let Some(ref local_var_str) = name__nic {
10038        local_var_req_builder = match "multi" {
10039            "multi" => local_var_req_builder.query(
10040                &local_var_str
10041                    .into_iter()
10042                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10044            ),
10045            _ => local_var_req_builder.query(&[(
10046                "name__nic",
10047                &local_var_str
10048                    .into_iter()
10049                    .map(|p| p.to_string())
10050                    .collect::<Vec<String>>()
10051                    .join(",")
10052                    .to_string(),
10053            )]),
10054        };
10055    }
10056    if let Some(ref local_var_str) = name__nie {
10057        local_var_req_builder = match "multi" {
10058            "multi" => local_var_req_builder.query(
10059                &local_var_str
10060                    .into_iter()
10061                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10063            ),
10064            _ => local_var_req_builder.query(&[(
10065                "name__nie",
10066                &local_var_str
10067                    .into_iter()
10068                    .map(|p| p.to_string())
10069                    .collect::<Vec<String>>()
10070                    .join(",")
10071                    .to_string(),
10072            )]),
10073        };
10074    }
10075    if let Some(ref local_var_str) = name__niew {
10076        local_var_req_builder = match "multi" {
10077            "multi" => local_var_req_builder.query(
10078                &local_var_str
10079                    .into_iter()
10080                    .map(|p| ("name__niew".to_owned(), p.to_string()))
10081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10082            ),
10083            _ => local_var_req_builder.query(&[(
10084                "name__niew",
10085                &local_var_str
10086                    .into_iter()
10087                    .map(|p| p.to_string())
10088                    .collect::<Vec<String>>()
10089                    .join(",")
10090                    .to_string(),
10091            )]),
10092        };
10093    }
10094    if let Some(ref local_var_str) = name__nisw {
10095        local_var_req_builder = match "multi" {
10096            "multi" => local_var_req_builder.query(
10097                &local_var_str
10098                    .into_iter()
10099                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
10100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10101            ),
10102            _ => local_var_req_builder.query(&[(
10103                "name__nisw",
10104                &local_var_str
10105                    .into_iter()
10106                    .map(|p| p.to_string())
10107                    .collect::<Vec<String>>()
10108                    .join(",")
10109                    .to_string(),
10110            )]),
10111        };
10112    }
10113    if let Some(ref local_var_str) = name__regex {
10114        local_var_req_builder = match "multi" {
10115            "multi" => local_var_req_builder.query(
10116                &local_var_str
10117                    .into_iter()
10118                    .map(|p| ("name__regex".to_owned(), p.to_string()))
10119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10120            ),
10121            _ => local_var_req_builder.query(&[(
10122                "name__regex",
10123                &local_var_str
10124                    .into_iter()
10125                    .map(|p| p.to_string())
10126                    .collect::<Vec<String>>()
10127                    .join(",")
10128                    .to_string(),
10129            )]),
10130        };
10131    }
10132    if let Some(ref local_var_str) = offset {
10133        local_var_req_builder =
10134            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10135    }
10136    if let Some(ref local_var_str) = ordering {
10137        local_var_req_builder =
10138            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
10139    }
10140    if let Some(ref local_var_str) = owner {
10141        local_var_req_builder = match "multi" {
10142            "multi" => local_var_req_builder.query(
10143                &local_var_str
10144                    .into_iter()
10145                    .map(|p| ("owner".to_owned(), p.to_string()))
10146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10147            ),
10148            _ => local_var_req_builder.query(&[(
10149                "owner",
10150                &local_var_str
10151                    .into_iter()
10152                    .map(|p| p.to_string())
10153                    .collect::<Vec<String>>()
10154                    .join(",")
10155                    .to_string(),
10156            )]),
10157        };
10158    }
10159    if let Some(ref local_var_str) = owner__n {
10160        local_var_req_builder = match "multi" {
10161            "multi" => local_var_req_builder.query(
10162                &local_var_str
10163                    .into_iter()
10164                    .map(|p| ("owner__n".to_owned(), p.to_string()))
10165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10166            ),
10167            _ => local_var_req_builder.query(&[(
10168                "owner__n",
10169                &local_var_str
10170                    .into_iter()
10171                    .map(|p| p.to_string())
10172                    .collect::<Vec<String>>()
10173                    .join(",")
10174                    .to_string(),
10175            )]),
10176        };
10177    }
10178    if let Some(ref local_var_str) = owner_group {
10179        local_var_req_builder = match "multi" {
10180            "multi" => local_var_req_builder.query(
10181                &local_var_str
10182                    .into_iter()
10183                    .map(|p| ("owner_group".to_owned(), p.to_string()))
10184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10185            ),
10186            _ => local_var_req_builder.query(&[(
10187                "owner_group",
10188                &local_var_str
10189                    .into_iter()
10190                    .map(|p| p.to_string())
10191                    .collect::<Vec<String>>()
10192                    .join(",")
10193                    .to_string(),
10194            )]),
10195        };
10196    }
10197    if let Some(ref local_var_str) = owner_group__n {
10198        local_var_req_builder = match "multi" {
10199            "multi" => local_var_req_builder.query(
10200                &local_var_str
10201                    .into_iter()
10202                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
10203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10204            ),
10205            _ => local_var_req_builder.query(&[(
10206                "owner_group__n",
10207                &local_var_str
10208                    .into_iter()
10209                    .map(|p| p.to_string())
10210                    .collect::<Vec<String>>()
10211                    .join(",")
10212                    .to_string(),
10213            )]),
10214        };
10215    }
10216    if let Some(ref local_var_str) = owner_group_id {
10217        local_var_req_builder = match "multi" {
10218            "multi" => local_var_req_builder.query(
10219                &local_var_str
10220                    .into_iter()
10221                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
10222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10223            ),
10224            _ => local_var_req_builder.query(&[(
10225                "owner_group_id",
10226                &local_var_str
10227                    .into_iter()
10228                    .map(|p| p.to_string())
10229                    .collect::<Vec<String>>()
10230                    .join(",")
10231                    .to_string(),
10232            )]),
10233        };
10234    }
10235    if let Some(ref local_var_str) = owner_group_id__n {
10236        local_var_req_builder = match "multi" {
10237            "multi" => local_var_req_builder.query(
10238                &local_var_str
10239                    .into_iter()
10240                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
10241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10242            ),
10243            _ => local_var_req_builder.query(&[(
10244                "owner_group_id__n",
10245                &local_var_str
10246                    .into_iter()
10247                    .map(|p| p.to_string())
10248                    .collect::<Vec<String>>()
10249                    .join(",")
10250                    .to_string(),
10251            )]),
10252        };
10253    }
10254    if let Some(ref local_var_str) = owner_id {
10255        local_var_req_builder = match "multi" {
10256            "multi" => local_var_req_builder.query(
10257                &local_var_str
10258                    .into_iter()
10259                    .map(|p| ("owner_id".to_owned(), p.to_string()))
10260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10261            ),
10262            _ => local_var_req_builder.query(&[(
10263                "owner_id",
10264                &local_var_str
10265                    .into_iter()
10266                    .map(|p| p.to_string())
10267                    .collect::<Vec<String>>()
10268                    .join(",")
10269                    .to_string(),
10270            )]),
10271        };
10272    }
10273    if let Some(ref local_var_str) = owner_id__n {
10274        local_var_req_builder = match "multi" {
10275            "multi" => local_var_req_builder.query(
10276                &local_var_str
10277                    .into_iter()
10278                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
10279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10280            ),
10281            _ => local_var_req_builder.query(&[(
10282                "owner_id__n",
10283                &local_var_str
10284                    .into_iter()
10285                    .map(|p| p.to_string())
10286                    .collect::<Vec<String>>()
10287                    .join(",")
10288                    .to_string(),
10289            )]),
10290        };
10291    }
10292    if let Some(ref local_var_str) = parent {
10293        local_var_req_builder = match "multi" {
10294            "multi" => local_var_req_builder.query(
10295                &local_var_str
10296                    .into_iter()
10297                    .map(|p| ("parent".to_owned(), p.to_string()))
10298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10299            ),
10300            _ => local_var_req_builder.query(&[(
10301                "parent",
10302                &local_var_str
10303                    .into_iter()
10304                    .map(|p| p.to_string())
10305                    .collect::<Vec<String>>()
10306                    .join(",")
10307                    .to_string(),
10308            )]),
10309        };
10310    }
10311    if let Some(ref local_var_str) = parent__n {
10312        local_var_req_builder = match "multi" {
10313            "multi" => local_var_req_builder.query(
10314                &local_var_str
10315                    .into_iter()
10316                    .map(|p| ("parent__n".to_owned(), p.to_string()))
10317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10318            ),
10319            _ => local_var_req_builder.query(&[(
10320                "parent__n",
10321                &local_var_str
10322                    .into_iter()
10323                    .map(|p| p.to_string())
10324                    .collect::<Vec<String>>()
10325                    .join(",")
10326                    .to_string(),
10327            )]),
10328        };
10329    }
10330    if let Some(ref local_var_str) = parent_id {
10331        local_var_req_builder = match "multi" {
10332            "multi" => local_var_req_builder.query(
10333                &local_var_str
10334                    .into_iter()
10335                    .map(|p| ("parent_id".to_owned(), p.to_string()))
10336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10337            ),
10338            _ => local_var_req_builder.query(&[(
10339                "parent_id",
10340                &local_var_str
10341                    .into_iter()
10342                    .map(|p| p.to_string())
10343                    .collect::<Vec<String>>()
10344                    .join(",")
10345                    .to_string(),
10346            )]),
10347        };
10348    }
10349    if let Some(ref local_var_str) = parent_id__n {
10350        local_var_req_builder = match "multi" {
10351            "multi" => local_var_req_builder.query(
10352                &local_var_str
10353                    .into_iter()
10354                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
10355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10356            ),
10357            _ => local_var_req_builder.query(&[(
10358                "parent_id__n",
10359                &local_var_str
10360                    .into_iter()
10361                    .map(|p| p.to_string())
10362                    .collect::<Vec<String>>()
10363                    .join(",")
10364                    .to_string(),
10365            )]),
10366        };
10367    }
10368    if let Some(ref local_var_str) = q {
10369        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
10370    }
10371    if let Some(ref local_var_str) = slug {
10372        local_var_req_builder = match "multi" {
10373            "multi" => local_var_req_builder.query(
10374                &local_var_str
10375                    .into_iter()
10376                    .map(|p| ("slug".to_owned(), p.to_string()))
10377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10378            ),
10379            _ => local_var_req_builder.query(&[(
10380                "slug",
10381                &local_var_str
10382                    .into_iter()
10383                    .map(|p| p.to_string())
10384                    .collect::<Vec<String>>()
10385                    .join(",")
10386                    .to_string(),
10387            )]),
10388        };
10389    }
10390    if let Some(ref local_var_str) = slug__empty {
10391        local_var_req_builder =
10392            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
10393    }
10394    if let Some(ref local_var_str) = slug__ic {
10395        local_var_req_builder = match "multi" {
10396            "multi" => local_var_req_builder.query(
10397                &local_var_str
10398                    .into_iter()
10399                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
10400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10401            ),
10402            _ => local_var_req_builder.query(&[(
10403                "slug__ic",
10404                &local_var_str
10405                    .into_iter()
10406                    .map(|p| p.to_string())
10407                    .collect::<Vec<String>>()
10408                    .join(",")
10409                    .to_string(),
10410            )]),
10411        };
10412    }
10413    if let Some(ref local_var_str) = slug__ie {
10414        local_var_req_builder = match "multi" {
10415            "multi" => local_var_req_builder.query(
10416                &local_var_str
10417                    .into_iter()
10418                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
10419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10420            ),
10421            _ => local_var_req_builder.query(&[(
10422                "slug__ie",
10423                &local_var_str
10424                    .into_iter()
10425                    .map(|p| p.to_string())
10426                    .collect::<Vec<String>>()
10427                    .join(",")
10428                    .to_string(),
10429            )]),
10430        };
10431    }
10432    if let Some(ref local_var_str) = slug__iew {
10433        local_var_req_builder = match "multi" {
10434            "multi" => local_var_req_builder.query(
10435                &local_var_str
10436                    .into_iter()
10437                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
10438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10439            ),
10440            _ => local_var_req_builder.query(&[(
10441                "slug__iew",
10442                &local_var_str
10443                    .into_iter()
10444                    .map(|p| p.to_string())
10445                    .collect::<Vec<String>>()
10446                    .join(",")
10447                    .to_string(),
10448            )]),
10449        };
10450    }
10451    if let Some(ref local_var_str) = slug__iregex {
10452        local_var_req_builder = match "multi" {
10453            "multi" => local_var_req_builder.query(
10454                &local_var_str
10455                    .into_iter()
10456                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
10457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10458            ),
10459            _ => local_var_req_builder.query(&[(
10460                "slug__iregex",
10461                &local_var_str
10462                    .into_iter()
10463                    .map(|p| p.to_string())
10464                    .collect::<Vec<String>>()
10465                    .join(",")
10466                    .to_string(),
10467            )]),
10468        };
10469    }
10470    if let Some(ref local_var_str) = slug__isw {
10471        local_var_req_builder = match "multi" {
10472            "multi" => local_var_req_builder.query(
10473                &local_var_str
10474                    .into_iter()
10475                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
10476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10477            ),
10478            _ => local_var_req_builder.query(&[(
10479                "slug__isw",
10480                &local_var_str
10481                    .into_iter()
10482                    .map(|p| p.to_string())
10483                    .collect::<Vec<String>>()
10484                    .join(",")
10485                    .to_string(),
10486            )]),
10487        };
10488    }
10489    if let Some(ref local_var_str) = slug__n {
10490        local_var_req_builder = match "multi" {
10491            "multi" => local_var_req_builder.query(
10492                &local_var_str
10493                    .into_iter()
10494                    .map(|p| ("slug__n".to_owned(), p.to_string()))
10495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10496            ),
10497            _ => local_var_req_builder.query(&[(
10498                "slug__n",
10499                &local_var_str
10500                    .into_iter()
10501                    .map(|p| p.to_string())
10502                    .collect::<Vec<String>>()
10503                    .join(",")
10504                    .to_string(),
10505            )]),
10506        };
10507    }
10508    if let Some(ref local_var_str) = slug__nic {
10509        local_var_req_builder = match "multi" {
10510            "multi" => local_var_req_builder.query(
10511                &local_var_str
10512                    .into_iter()
10513                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
10514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10515            ),
10516            _ => local_var_req_builder.query(&[(
10517                "slug__nic",
10518                &local_var_str
10519                    .into_iter()
10520                    .map(|p| p.to_string())
10521                    .collect::<Vec<String>>()
10522                    .join(",")
10523                    .to_string(),
10524            )]),
10525        };
10526    }
10527    if let Some(ref local_var_str) = slug__nie {
10528        local_var_req_builder = match "multi" {
10529            "multi" => local_var_req_builder.query(
10530                &local_var_str
10531                    .into_iter()
10532                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
10533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10534            ),
10535            _ => local_var_req_builder.query(&[(
10536                "slug__nie",
10537                &local_var_str
10538                    .into_iter()
10539                    .map(|p| p.to_string())
10540                    .collect::<Vec<String>>()
10541                    .join(",")
10542                    .to_string(),
10543            )]),
10544        };
10545    }
10546    if let Some(ref local_var_str) = slug__niew {
10547        local_var_req_builder = match "multi" {
10548            "multi" => local_var_req_builder.query(
10549                &local_var_str
10550                    .into_iter()
10551                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
10552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10553            ),
10554            _ => local_var_req_builder.query(&[(
10555                "slug__niew",
10556                &local_var_str
10557                    .into_iter()
10558                    .map(|p| p.to_string())
10559                    .collect::<Vec<String>>()
10560                    .join(",")
10561                    .to_string(),
10562            )]),
10563        };
10564    }
10565    if let Some(ref local_var_str) = slug__nisw {
10566        local_var_req_builder = match "multi" {
10567            "multi" => local_var_req_builder.query(
10568                &local_var_str
10569                    .into_iter()
10570                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
10571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10572            ),
10573            _ => local_var_req_builder.query(&[(
10574                "slug__nisw",
10575                &local_var_str
10576                    .into_iter()
10577                    .map(|p| p.to_string())
10578                    .collect::<Vec<String>>()
10579                    .join(",")
10580                    .to_string(),
10581            )]),
10582        };
10583    }
10584    if let Some(ref local_var_str) = slug__regex {
10585        local_var_req_builder = match "multi" {
10586            "multi" => local_var_req_builder.query(
10587                &local_var_str
10588                    .into_iter()
10589                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
10590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10591            ),
10592            _ => local_var_req_builder.query(&[(
10593                "slug__regex",
10594                &local_var_str
10595                    .into_iter()
10596                    .map(|p| p.to_string())
10597                    .collect::<Vec<String>>()
10598                    .join(",")
10599                    .to_string(),
10600            )]),
10601        };
10602    }
10603    if let Some(ref local_var_str) = start {
10604        local_var_req_builder =
10605            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
10606    }
10607    if let Some(ref local_var_str) = tag {
10608        local_var_req_builder = match "multi" {
10609            "multi" => local_var_req_builder.query(
10610                &local_var_str
10611                    .into_iter()
10612                    .map(|p| ("tag".to_owned(), p.to_string()))
10613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10614            ),
10615            _ => local_var_req_builder.query(&[(
10616                "tag",
10617                &local_var_str
10618                    .into_iter()
10619                    .map(|p| p.to_string())
10620                    .collect::<Vec<String>>()
10621                    .join(",")
10622                    .to_string(),
10623            )]),
10624        };
10625    }
10626    if let Some(ref local_var_str) = tag__n {
10627        local_var_req_builder = match "multi" {
10628            "multi" => local_var_req_builder.query(
10629                &local_var_str
10630                    .into_iter()
10631                    .map(|p| ("tag__n".to_owned(), p.to_string()))
10632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10633            ),
10634            _ => local_var_req_builder.query(&[(
10635                "tag__n",
10636                &local_var_str
10637                    .into_iter()
10638                    .map(|p| p.to_string())
10639                    .collect::<Vec<String>>()
10640                    .join(",")
10641                    .to_string(),
10642            )]),
10643        };
10644    }
10645    if let Some(ref local_var_str) = tag_id {
10646        local_var_req_builder = match "multi" {
10647            "multi" => local_var_req_builder.query(
10648                &local_var_str
10649                    .into_iter()
10650                    .map(|p| ("tag_id".to_owned(), p.to_string()))
10651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10652            ),
10653            _ => local_var_req_builder.query(&[(
10654                "tag_id",
10655                &local_var_str
10656                    .into_iter()
10657                    .map(|p| p.to_string())
10658                    .collect::<Vec<String>>()
10659                    .join(",")
10660                    .to_string(),
10661            )]),
10662        };
10663    }
10664    if let Some(ref local_var_str) = tag_id__n {
10665        local_var_req_builder = match "multi" {
10666            "multi" => local_var_req_builder.query(
10667                &local_var_str
10668                    .into_iter()
10669                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
10670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10671            ),
10672            _ => local_var_req_builder.query(&[(
10673                "tag_id__n",
10674                &local_var_str
10675                    .into_iter()
10676                    .map(|p| p.to_string())
10677                    .collect::<Vec<String>>()
10678                    .join(",")
10679                    .to_string(),
10680            )]),
10681        };
10682    }
10683    if let Some(ref local_var_str) = updated_by_request {
10684        local_var_req_builder =
10685            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
10686    }
10687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10688        local_var_req_builder =
10689            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10690    }
10691    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10692        let local_var_key = local_var_apikey.key.clone();
10693        let local_var_value = match local_var_apikey.prefix {
10694            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10695            None => local_var_key,
10696        };
10697        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10698    };
10699
10700    let local_var_req = local_var_req_builder.build()?;
10701    let local_var_resp = local_var_client.execute(local_var_req).await?;
10702
10703    let local_var_status = local_var_resp.status();
10704    let local_var_content = local_var_resp.text().await?;
10705
10706    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10707        serde_json::from_str(&local_var_content).map_err(Error::from)
10708    } else {
10709        let local_var_entity: Option<TenancyTenantGroupsListError> =
10710            serde_json::from_str(&local_var_content).ok();
10711        let local_var_error = ResponseContent {
10712            status: local_var_status,
10713            content: local_var_content,
10714            entity: local_var_entity,
10715        };
10716        Err(Error::ResponseError(local_var_error))
10717    }
10718}
10719
10720/// Patch a tenant group object.
10721pub async fn tenancy_tenant_groups_partial_update(
10722    configuration: &configuration::Configuration,
10723    id: i32,
10724    patched_writable_tenant_group_request: Option<crate::models::PatchedWritableTenantGroupRequest>,
10725) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsPartialUpdateError>> {
10726    let local_var_configuration = configuration;
10727
10728    let local_var_client = &local_var_configuration.client;
10729
10730    let local_var_uri_str = format!(
10731        "{}/api/tenancy/tenant-groups/{id}/",
10732        local_var_configuration.base_path,
10733        id = id
10734    );
10735    let mut local_var_req_builder =
10736        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10737
10738    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10739        local_var_req_builder =
10740            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10741    }
10742    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10743        let local_var_key = local_var_apikey.key.clone();
10744        let local_var_value = match local_var_apikey.prefix {
10745            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10746            None => local_var_key,
10747        };
10748        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10749    };
10750    local_var_req_builder = local_var_req_builder.json(&patched_writable_tenant_group_request);
10751
10752    let local_var_req = local_var_req_builder.build()?;
10753    let local_var_resp = local_var_client.execute(local_var_req).await?;
10754
10755    let local_var_status = local_var_resp.status();
10756    let local_var_content = local_var_resp.text().await?;
10757
10758    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10759        serde_json::from_str(&local_var_content).map_err(Error::from)
10760    } else {
10761        let local_var_entity: Option<TenancyTenantGroupsPartialUpdateError> =
10762            serde_json::from_str(&local_var_content).ok();
10763        let local_var_error = ResponseContent {
10764            status: local_var_status,
10765            content: local_var_content,
10766            entity: local_var_entity,
10767        };
10768        Err(Error::ResponseError(local_var_error))
10769    }
10770}
10771
10772/// Get a tenant group object.
10773pub async fn tenancy_tenant_groups_retrieve(
10774    configuration: &configuration::Configuration,
10775    id: i32,
10776) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsRetrieveError>> {
10777    let local_var_configuration = configuration;
10778
10779    let local_var_client = &local_var_configuration.client;
10780
10781    let local_var_uri_str = format!(
10782        "{}/api/tenancy/tenant-groups/{id}/",
10783        local_var_configuration.base_path,
10784        id = id
10785    );
10786    let mut local_var_req_builder =
10787        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10788
10789    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10790        local_var_req_builder =
10791            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10792    }
10793    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10794        let local_var_key = local_var_apikey.key.clone();
10795        let local_var_value = match local_var_apikey.prefix {
10796            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10797            None => local_var_key,
10798        };
10799        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10800    };
10801
10802    let local_var_req = local_var_req_builder.build()?;
10803    let local_var_resp = local_var_client.execute(local_var_req).await?;
10804
10805    let local_var_status = local_var_resp.status();
10806    let local_var_content = local_var_resp.text().await?;
10807
10808    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10809        serde_json::from_str(&local_var_content).map_err(Error::from)
10810    } else {
10811        let local_var_entity: Option<TenancyTenantGroupsRetrieveError> =
10812            serde_json::from_str(&local_var_content).ok();
10813        let local_var_error = ResponseContent {
10814            status: local_var_status,
10815            content: local_var_content,
10816            entity: local_var_entity,
10817        };
10818        Err(Error::ResponseError(local_var_error))
10819    }
10820}
10821
10822/// Put a tenant group object.
10823pub async fn tenancy_tenant_groups_update(
10824    configuration: &configuration::Configuration,
10825    id: i32,
10826    writable_tenant_group_request: crate::models::WritableTenantGroupRequest,
10827) -> Result<crate::models::TenantGroup, Error<TenancyTenantGroupsUpdateError>> {
10828    let local_var_configuration = configuration;
10829
10830    let local_var_client = &local_var_configuration.client;
10831
10832    let local_var_uri_str = format!(
10833        "{}/api/tenancy/tenant-groups/{id}/",
10834        local_var_configuration.base_path,
10835        id = id
10836    );
10837    let mut local_var_req_builder =
10838        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10839
10840    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10841        local_var_req_builder =
10842            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10843    }
10844    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10845        let local_var_key = local_var_apikey.key.clone();
10846        let local_var_value = match local_var_apikey.prefix {
10847            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10848            None => local_var_key,
10849        };
10850        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10851    };
10852    local_var_req_builder = local_var_req_builder.json(&writable_tenant_group_request);
10853
10854    let local_var_req = local_var_req_builder.build()?;
10855    let local_var_resp = local_var_client.execute(local_var_req).await?;
10856
10857    let local_var_status = local_var_resp.status();
10858    let local_var_content = local_var_resp.text().await?;
10859
10860    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10861        serde_json::from_str(&local_var_content).map_err(Error::from)
10862    } else {
10863        let local_var_entity: Option<TenancyTenantGroupsUpdateError> =
10864            serde_json::from_str(&local_var_content).ok();
10865        let local_var_error = ResponseContent {
10866            status: local_var_status,
10867            content: local_var_content,
10868            entity: local_var_entity,
10869        };
10870        Err(Error::ResponseError(local_var_error))
10871    }
10872}
10873
10874/// Delete a list of tenant objects.
10875pub async fn tenancy_tenants_bulk_destroy(
10876    configuration: &configuration::Configuration,
10877    tenant_request: Vec<crate::models::TenantRequest>,
10878) -> Result<(), Error<TenancyTenantsBulkDestroyError>> {
10879    let local_var_configuration = configuration;
10880
10881    let local_var_client = &local_var_configuration.client;
10882
10883    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10884    let mut local_var_req_builder =
10885        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10886
10887    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10888        local_var_req_builder =
10889            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10890    }
10891    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10892        let local_var_key = local_var_apikey.key.clone();
10893        let local_var_value = match local_var_apikey.prefix {
10894            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10895            None => local_var_key,
10896        };
10897        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10898    };
10899    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10900
10901    let local_var_req = local_var_req_builder.build()?;
10902    let local_var_resp = local_var_client.execute(local_var_req).await?;
10903
10904    let local_var_status = local_var_resp.status();
10905    let local_var_content = local_var_resp.text().await?;
10906
10907    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10908        Ok(())
10909    } else {
10910        let local_var_entity: Option<TenancyTenantsBulkDestroyError> =
10911            serde_json::from_str(&local_var_content).ok();
10912        let local_var_error = ResponseContent {
10913            status: local_var_status,
10914            content: local_var_content,
10915            entity: local_var_entity,
10916        };
10917        Err(Error::ResponseError(local_var_error))
10918    }
10919}
10920
10921/// Patch a list of tenant objects.
10922pub async fn tenancy_tenants_bulk_partial_update(
10923    configuration: &configuration::Configuration,
10924    tenant_request: Vec<crate::models::TenantRequest>,
10925) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkPartialUpdateError>> {
10926    let local_var_configuration = configuration;
10927
10928    let local_var_client = &local_var_configuration.client;
10929
10930    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10931    let mut local_var_req_builder =
10932        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10933
10934    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10935        local_var_req_builder =
10936            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10937    }
10938    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10939        let local_var_key = local_var_apikey.key.clone();
10940        let local_var_value = match local_var_apikey.prefix {
10941            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10942            None => local_var_key,
10943        };
10944        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10945    };
10946    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10947
10948    let local_var_req = local_var_req_builder.build()?;
10949    let local_var_resp = local_var_client.execute(local_var_req).await?;
10950
10951    let local_var_status = local_var_resp.status();
10952    let local_var_content = local_var_resp.text().await?;
10953
10954    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10955        serde_json::from_str(&local_var_content).map_err(Error::from)
10956    } else {
10957        let local_var_entity: Option<TenancyTenantsBulkPartialUpdateError> =
10958            serde_json::from_str(&local_var_content).ok();
10959        let local_var_error = ResponseContent {
10960            status: local_var_status,
10961            content: local_var_content,
10962            entity: local_var_entity,
10963        };
10964        Err(Error::ResponseError(local_var_error))
10965    }
10966}
10967
10968/// Put a list of tenant objects.
10969pub async fn tenancy_tenants_bulk_update(
10970    configuration: &configuration::Configuration,
10971    tenant_request: Vec<crate::models::TenantRequest>,
10972) -> Result<Vec<crate::models::Tenant>, Error<TenancyTenantsBulkUpdateError>> {
10973    let local_var_configuration = configuration;
10974
10975    let local_var_client = &local_var_configuration.client;
10976
10977    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
10978    let mut local_var_req_builder =
10979        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10980
10981    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10982        local_var_req_builder =
10983            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10984    }
10985    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10986        let local_var_key = local_var_apikey.key.clone();
10987        let local_var_value = match local_var_apikey.prefix {
10988            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10989            None => local_var_key,
10990        };
10991        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10992    };
10993    local_var_req_builder = local_var_req_builder.json(&tenant_request);
10994
10995    let local_var_req = local_var_req_builder.build()?;
10996    let local_var_resp = local_var_client.execute(local_var_req).await?;
10997
10998    let local_var_status = local_var_resp.status();
10999    let local_var_content = local_var_resp.text().await?;
11000
11001    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11002        serde_json::from_str(&local_var_content).map_err(Error::from)
11003    } else {
11004        let local_var_entity: Option<TenancyTenantsBulkUpdateError> =
11005            serde_json::from_str(&local_var_content).ok();
11006        let local_var_error = ResponseContent {
11007            status: local_var_status,
11008            content: local_var_content,
11009            entity: local_var_entity,
11010        };
11011        Err(Error::ResponseError(local_var_error))
11012    }
11013}
11014
11015/// Post a list of tenant objects.
11016pub async fn tenancy_tenants_create(
11017    configuration: &configuration::Configuration,
11018    tenancy_tenants_create_request: crate::models::TenancyTenantsCreateRequest,
11019) -> Result<crate::models::Tenant, Error<TenancyTenantsCreateError>> {
11020    let local_var_configuration = configuration;
11021
11022    let local_var_client = &local_var_configuration.client;
11023
11024    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
11025    let mut local_var_req_builder =
11026        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11027
11028    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11029        local_var_req_builder =
11030            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11031    }
11032    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11033        let local_var_key = local_var_apikey.key.clone();
11034        let local_var_value = match local_var_apikey.prefix {
11035            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11036            None => local_var_key,
11037        };
11038        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11039    };
11040    local_var_req_builder = local_var_req_builder.json(&tenancy_tenants_create_request);
11041
11042    let local_var_req = local_var_req_builder.build()?;
11043    let local_var_resp = local_var_client.execute(local_var_req).await?;
11044
11045    let local_var_status = local_var_resp.status();
11046    let local_var_content = local_var_resp.text().await?;
11047
11048    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11049        serde_json::from_str(&local_var_content).map_err(Error::from)
11050    } else {
11051        let local_var_entity: Option<TenancyTenantsCreateError> =
11052            serde_json::from_str(&local_var_content).ok();
11053        let local_var_error = ResponseContent {
11054            status: local_var_status,
11055            content: local_var_content,
11056            entity: local_var_entity,
11057        };
11058        Err(Error::ResponseError(local_var_error))
11059    }
11060}
11061
11062/// Delete a tenant object.
11063pub async fn tenancy_tenants_destroy(
11064    configuration: &configuration::Configuration,
11065    id: i32,
11066) -> Result<(), Error<TenancyTenantsDestroyError>> {
11067    let local_var_configuration = configuration;
11068
11069    let local_var_client = &local_var_configuration.client;
11070
11071    let local_var_uri_str = format!(
11072        "{}/api/tenancy/tenants/{id}/",
11073        local_var_configuration.base_path,
11074        id = id
11075    );
11076    let mut local_var_req_builder =
11077        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11078
11079    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11080        local_var_req_builder =
11081            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11082    }
11083    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11084        let local_var_key = local_var_apikey.key.clone();
11085        let local_var_value = match local_var_apikey.prefix {
11086            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11087            None => local_var_key,
11088        };
11089        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11090    };
11091
11092    let local_var_req = local_var_req_builder.build()?;
11093    let local_var_resp = local_var_client.execute(local_var_req).await?;
11094
11095    let local_var_status = local_var_resp.status();
11096    let local_var_content = local_var_resp.text().await?;
11097
11098    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11099        Ok(())
11100    } else {
11101        let local_var_entity: Option<TenancyTenantsDestroyError> =
11102            serde_json::from_str(&local_var_content).ok();
11103        let local_var_error = ResponseContent {
11104            status: local_var_status,
11105            content: local_var_content,
11106            entity: local_var_entity,
11107        };
11108        Err(Error::ResponseError(local_var_error))
11109    }
11110}
11111
11112/// Get a list of tenant objects.
11113pub async fn tenancy_tenants_list(
11114    configuration: &configuration::Configuration,
11115    contact: Option<Vec<i32>>,
11116    contact__n: Option<Vec<i32>>,
11117    contact_group: Option<Vec<String>>,
11118    contact_group__n: Option<Vec<String>>,
11119    contact_role: Option<Vec<i32>>,
11120    contact_role__n: Option<Vec<i32>>,
11121    created: Option<Vec<String>>,
11122    created__empty: Option<Vec<String>>,
11123    created__gt: Option<Vec<String>>,
11124    created__gte: Option<Vec<String>>,
11125    created__lt: Option<Vec<String>>,
11126    created__lte: Option<Vec<String>>,
11127    created__n: Option<Vec<String>>,
11128    created_by_request: Option<&str>,
11129    description: Option<Vec<String>>,
11130    description__empty: Option<bool>,
11131    description__ic: Option<Vec<String>>,
11132    description__ie: Option<Vec<String>>,
11133    description__iew: Option<Vec<String>>,
11134    description__iregex: Option<Vec<String>>,
11135    description__isw: Option<Vec<String>>,
11136    description__n: Option<Vec<String>>,
11137    description__nic: Option<Vec<String>>,
11138    description__nie: Option<Vec<String>>,
11139    description__niew: Option<Vec<String>>,
11140    description__nisw: Option<Vec<String>>,
11141    description__regex: Option<Vec<String>>,
11142    group: Option<Vec<String>>,
11143    group__n: Option<Vec<String>>,
11144    group_id: Option<Vec<String>>,
11145    group_id__n: Option<Vec<String>>,
11146    id: Option<Vec<i32>>,
11147    id__empty: Option<bool>,
11148    id__gt: Option<Vec<i32>>,
11149    id__gte: Option<Vec<i32>>,
11150    id__lt: Option<Vec<i32>>,
11151    id__lte: Option<Vec<i32>>,
11152    id__n: Option<Vec<i32>>,
11153    last_updated: Option<Vec<String>>,
11154    last_updated__empty: Option<Vec<String>>,
11155    last_updated__gt: Option<Vec<String>>,
11156    last_updated__gte: Option<Vec<String>>,
11157    last_updated__lt: Option<Vec<String>>,
11158    last_updated__lte: Option<Vec<String>>,
11159    last_updated__n: Option<Vec<String>>,
11160    limit: Option<i32>,
11161    modified_by_request: Option<&str>,
11162    name: Option<Vec<String>>,
11163    name__empty: Option<bool>,
11164    name__ic: Option<Vec<String>>,
11165    name__ie: Option<Vec<String>>,
11166    name__iew: Option<Vec<String>>,
11167    name__iregex: Option<Vec<String>>,
11168    name__isw: Option<Vec<String>>,
11169    name__n: Option<Vec<String>>,
11170    name__nic: Option<Vec<String>>,
11171    name__nie: Option<Vec<String>>,
11172    name__niew: Option<Vec<String>>,
11173    name__nisw: Option<Vec<String>>,
11174    name__regex: Option<Vec<String>>,
11175    offset: Option<i32>,
11176    ordering: Option<&str>,
11177    owner: Option<Vec<String>>,
11178    owner__n: Option<Vec<String>>,
11179    owner_group: Option<Vec<String>>,
11180    owner_group__n: Option<Vec<String>>,
11181    owner_group_id: Option<Vec<i32>>,
11182    owner_group_id__n: Option<Vec<i32>>,
11183    owner_id: Option<Vec<i32>>,
11184    owner_id__n: Option<Vec<i32>>,
11185    q: Option<&str>,
11186    slug: Option<Vec<String>>,
11187    slug__empty: Option<bool>,
11188    slug__ic: Option<Vec<String>>,
11189    slug__ie: Option<Vec<String>>,
11190    slug__iew: Option<Vec<String>>,
11191    slug__iregex: Option<Vec<String>>,
11192    slug__isw: Option<Vec<String>>,
11193    slug__n: Option<Vec<String>>,
11194    slug__nic: Option<Vec<String>>,
11195    slug__nie: Option<Vec<String>>,
11196    slug__niew: Option<Vec<String>>,
11197    slug__nisw: Option<Vec<String>>,
11198    slug__regex: Option<Vec<String>>,
11199    start: Option<i32>,
11200    tag: Option<Vec<String>>,
11201    tag__n: Option<Vec<String>>,
11202    tag_id: Option<Vec<i32>>,
11203    tag_id__n: Option<Vec<i32>>,
11204    updated_by_request: Option<&str>,
11205) -> Result<crate::models::PaginatedTenantList, Error<TenancyTenantsListError>> {
11206    let local_var_configuration = configuration;
11207
11208    let local_var_client = &local_var_configuration.client;
11209
11210    let local_var_uri_str = format!("{}/api/tenancy/tenants/", local_var_configuration.base_path);
11211    let mut local_var_req_builder =
11212        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11213
11214    if let Some(ref local_var_str) = contact {
11215        local_var_req_builder = match "multi" {
11216            "multi" => local_var_req_builder.query(
11217                &local_var_str
11218                    .into_iter()
11219                    .map(|p| ("contact".to_owned(), p.to_string()))
11220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11221            ),
11222            _ => local_var_req_builder.query(&[(
11223                "contact",
11224                &local_var_str
11225                    .into_iter()
11226                    .map(|p| p.to_string())
11227                    .collect::<Vec<String>>()
11228                    .join(",")
11229                    .to_string(),
11230            )]),
11231        };
11232    }
11233    if let Some(ref local_var_str) = contact__n {
11234        local_var_req_builder = match "multi" {
11235            "multi" => local_var_req_builder.query(
11236                &local_var_str
11237                    .into_iter()
11238                    .map(|p| ("contact__n".to_owned(), p.to_string()))
11239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11240            ),
11241            _ => local_var_req_builder.query(&[(
11242                "contact__n",
11243                &local_var_str
11244                    .into_iter()
11245                    .map(|p| p.to_string())
11246                    .collect::<Vec<String>>()
11247                    .join(",")
11248                    .to_string(),
11249            )]),
11250        };
11251    }
11252    if let Some(ref local_var_str) = contact_group {
11253        local_var_req_builder = match "multi" {
11254            "multi" => local_var_req_builder.query(
11255                &local_var_str
11256                    .into_iter()
11257                    .map(|p| ("contact_group".to_owned(), p.to_string()))
11258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11259            ),
11260            _ => local_var_req_builder.query(&[(
11261                "contact_group",
11262                &local_var_str
11263                    .into_iter()
11264                    .map(|p| p.to_string())
11265                    .collect::<Vec<String>>()
11266                    .join(",")
11267                    .to_string(),
11268            )]),
11269        };
11270    }
11271    if let Some(ref local_var_str) = contact_group__n {
11272        local_var_req_builder = match "multi" {
11273            "multi" => local_var_req_builder.query(
11274                &local_var_str
11275                    .into_iter()
11276                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
11277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11278            ),
11279            _ => local_var_req_builder.query(&[(
11280                "contact_group__n",
11281                &local_var_str
11282                    .into_iter()
11283                    .map(|p| p.to_string())
11284                    .collect::<Vec<String>>()
11285                    .join(",")
11286                    .to_string(),
11287            )]),
11288        };
11289    }
11290    if let Some(ref local_var_str) = contact_role {
11291        local_var_req_builder = match "multi" {
11292            "multi" => local_var_req_builder.query(
11293                &local_var_str
11294                    .into_iter()
11295                    .map(|p| ("contact_role".to_owned(), p.to_string()))
11296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11297            ),
11298            _ => local_var_req_builder.query(&[(
11299                "contact_role",
11300                &local_var_str
11301                    .into_iter()
11302                    .map(|p| p.to_string())
11303                    .collect::<Vec<String>>()
11304                    .join(",")
11305                    .to_string(),
11306            )]),
11307        };
11308    }
11309    if let Some(ref local_var_str) = contact_role__n {
11310        local_var_req_builder = match "multi" {
11311            "multi" => local_var_req_builder.query(
11312                &local_var_str
11313                    .into_iter()
11314                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
11315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11316            ),
11317            _ => local_var_req_builder.query(&[(
11318                "contact_role__n",
11319                &local_var_str
11320                    .into_iter()
11321                    .map(|p| p.to_string())
11322                    .collect::<Vec<String>>()
11323                    .join(",")
11324                    .to_string(),
11325            )]),
11326        };
11327    }
11328    if let Some(ref local_var_str) = created {
11329        local_var_req_builder = match "multi" {
11330            "multi" => local_var_req_builder.query(
11331                &local_var_str
11332                    .into_iter()
11333                    .map(|p| ("created".to_owned(), p.to_string()))
11334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11335            ),
11336            _ => local_var_req_builder.query(&[(
11337                "created",
11338                &local_var_str
11339                    .into_iter()
11340                    .map(|p| p.to_string())
11341                    .collect::<Vec<String>>()
11342                    .join(",")
11343                    .to_string(),
11344            )]),
11345        };
11346    }
11347    if let Some(ref local_var_str) = created__empty {
11348        local_var_req_builder = match "multi" {
11349            "multi" => local_var_req_builder.query(
11350                &local_var_str
11351                    .into_iter()
11352                    .map(|p| ("created__empty".to_owned(), p.to_string()))
11353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11354            ),
11355            _ => local_var_req_builder.query(&[(
11356                "created__empty",
11357                &local_var_str
11358                    .into_iter()
11359                    .map(|p| p.to_string())
11360                    .collect::<Vec<String>>()
11361                    .join(",")
11362                    .to_string(),
11363            )]),
11364        };
11365    }
11366    if let Some(ref local_var_str) = created__gt {
11367        local_var_req_builder = match "multi" {
11368            "multi" => local_var_req_builder.query(
11369                &local_var_str
11370                    .into_iter()
11371                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11373            ),
11374            _ => local_var_req_builder.query(&[(
11375                "created__gt",
11376                &local_var_str
11377                    .into_iter()
11378                    .map(|p| p.to_string())
11379                    .collect::<Vec<String>>()
11380                    .join(",")
11381                    .to_string(),
11382            )]),
11383        };
11384    }
11385    if let Some(ref local_var_str) = created__gte {
11386        local_var_req_builder = match "multi" {
11387            "multi" => local_var_req_builder.query(
11388                &local_var_str
11389                    .into_iter()
11390                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11392            ),
11393            _ => local_var_req_builder.query(&[(
11394                "created__gte",
11395                &local_var_str
11396                    .into_iter()
11397                    .map(|p| p.to_string())
11398                    .collect::<Vec<String>>()
11399                    .join(",")
11400                    .to_string(),
11401            )]),
11402        };
11403    }
11404    if let Some(ref local_var_str) = created__lt {
11405        local_var_req_builder = match "multi" {
11406            "multi" => local_var_req_builder.query(
11407                &local_var_str
11408                    .into_iter()
11409                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11411            ),
11412            _ => local_var_req_builder.query(&[(
11413                "created__lt",
11414                &local_var_str
11415                    .into_iter()
11416                    .map(|p| p.to_string())
11417                    .collect::<Vec<String>>()
11418                    .join(",")
11419                    .to_string(),
11420            )]),
11421        };
11422    }
11423    if let Some(ref local_var_str) = created__lte {
11424        local_var_req_builder = match "multi" {
11425            "multi" => local_var_req_builder.query(
11426                &local_var_str
11427                    .into_iter()
11428                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11430            ),
11431            _ => local_var_req_builder.query(&[(
11432                "created__lte",
11433                &local_var_str
11434                    .into_iter()
11435                    .map(|p| p.to_string())
11436                    .collect::<Vec<String>>()
11437                    .join(",")
11438                    .to_string(),
11439            )]),
11440        };
11441    }
11442    if let Some(ref local_var_str) = created__n {
11443        local_var_req_builder = match "multi" {
11444            "multi" => local_var_req_builder.query(
11445                &local_var_str
11446                    .into_iter()
11447                    .map(|p| ("created__n".to_owned(), p.to_string()))
11448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11449            ),
11450            _ => local_var_req_builder.query(&[(
11451                "created__n",
11452                &local_var_str
11453                    .into_iter()
11454                    .map(|p| p.to_string())
11455                    .collect::<Vec<String>>()
11456                    .join(",")
11457                    .to_string(),
11458            )]),
11459        };
11460    }
11461    if let Some(ref local_var_str) = created_by_request {
11462        local_var_req_builder =
11463            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
11464    }
11465    if let Some(ref local_var_str) = description {
11466        local_var_req_builder = match "multi" {
11467            "multi" => local_var_req_builder.query(
11468                &local_var_str
11469                    .into_iter()
11470                    .map(|p| ("description".to_owned(), p.to_string()))
11471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11472            ),
11473            _ => local_var_req_builder.query(&[(
11474                "description",
11475                &local_var_str
11476                    .into_iter()
11477                    .map(|p| p.to_string())
11478                    .collect::<Vec<String>>()
11479                    .join(",")
11480                    .to_string(),
11481            )]),
11482        };
11483    }
11484    if let Some(ref local_var_str) = description__empty {
11485        local_var_req_builder =
11486            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
11487    }
11488    if let Some(ref local_var_str) = description__ic {
11489        local_var_req_builder = match "multi" {
11490            "multi" => local_var_req_builder.query(
11491                &local_var_str
11492                    .into_iter()
11493                    .map(|p| ("description__ic".to_owned(), p.to_string()))
11494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11495            ),
11496            _ => local_var_req_builder.query(&[(
11497                "description__ic",
11498                &local_var_str
11499                    .into_iter()
11500                    .map(|p| p.to_string())
11501                    .collect::<Vec<String>>()
11502                    .join(",")
11503                    .to_string(),
11504            )]),
11505        };
11506    }
11507    if let Some(ref local_var_str) = description__ie {
11508        local_var_req_builder = match "multi" {
11509            "multi" => local_var_req_builder.query(
11510                &local_var_str
11511                    .into_iter()
11512                    .map(|p| ("description__ie".to_owned(), p.to_string()))
11513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11514            ),
11515            _ => local_var_req_builder.query(&[(
11516                "description__ie",
11517                &local_var_str
11518                    .into_iter()
11519                    .map(|p| p.to_string())
11520                    .collect::<Vec<String>>()
11521                    .join(",")
11522                    .to_string(),
11523            )]),
11524        };
11525    }
11526    if let Some(ref local_var_str) = description__iew {
11527        local_var_req_builder = match "multi" {
11528            "multi" => local_var_req_builder.query(
11529                &local_var_str
11530                    .into_iter()
11531                    .map(|p| ("description__iew".to_owned(), p.to_string()))
11532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11533            ),
11534            _ => local_var_req_builder.query(&[(
11535                "description__iew",
11536                &local_var_str
11537                    .into_iter()
11538                    .map(|p| p.to_string())
11539                    .collect::<Vec<String>>()
11540                    .join(",")
11541                    .to_string(),
11542            )]),
11543        };
11544    }
11545    if let Some(ref local_var_str) = description__iregex {
11546        local_var_req_builder = match "multi" {
11547            "multi" => local_var_req_builder.query(
11548                &local_var_str
11549                    .into_iter()
11550                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
11551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11552            ),
11553            _ => local_var_req_builder.query(&[(
11554                "description__iregex",
11555                &local_var_str
11556                    .into_iter()
11557                    .map(|p| p.to_string())
11558                    .collect::<Vec<String>>()
11559                    .join(",")
11560                    .to_string(),
11561            )]),
11562        };
11563    }
11564    if let Some(ref local_var_str) = description__isw {
11565        local_var_req_builder = match "multi" {
11566            "multi" => local_var_req_builder.query(
11567                &local_var_str
11568                    .into_iter()
11569                    .map(|p| ("description__isw".to_owned(), p.to_string()))
11570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11571            ),
11572            _ => local_var_req_builder.query(&[(
11573                "description__isw",
11574                &local_var_str
11575                    .into_iter()
11576                    .map(|p| p.to_string())
11577                    .collect::<Vec<String>>()
11578                    .join(",")
11579                    .to_string(),
11580            )]),
11581        };
11582    }
11583    if let Some(ref local_var_str) = description__n {
11584        local_var_req_builder = match "multi" {
11585            "multi" => local_var_req_builder.query(
11586                &local_var_str
11587                    .into_iter()
11588                    .map(|p| ("description__n".to_owned(), p.to_string()))
11589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11590            ),
11591            _ => local_var_req_builder.query(&[(
11592                "description__n",
11593                &local_var_str
11594                    .into_iter()
11595                    .map(|p| p.to_string())
11596                    .collect::<Vec<String>>()
11597                    .join(",")
11598                    .to_string(),
11599            )]),
11600        };
11601    }
11602    if let Some(ref local_var_str) = description__nic {
11603        local_var_req_builder = match "multi" {
11604            "multi" => local_var_req_builder.query(
11605                &local_var_str
11606                    .into_iter()
11607                    .map(|p| ("description__nic".to_owned(), p.to_string()))
11608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11609            ),
11610            _ => local_var_req_builder.query(&[(
11611                "description__nic",
11612                &local_var_str
11613                    .into_iter()
11614                    .map(|p| p.to_string())
11615                    .collect::<Vec<String>>()
11616                    .join(",")
11617                    .to_string(),
11618            )]),
11619        };
11620    }
11621    if let Some(ref local_var_str) = description__nie {
11622        local_var_req_builder = match "multi" {
11623            "multi" => local_var_req_builder.query(
11624                &local_var_str
11625                    .into_iter()
11626                    .map(|p| ("description__nie".to_owned(), p.to_string()))
11627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11628            ),
11629            _ => local_var_req_builder.query(&[(
11630                "description__nie",
11631                &local_var_str
11632                    .into_iter()
11633                    .map(|p| p.to_string())
11634                    .collect::<Vec<String>>()
11635                    .join(",")
11636                    .to_string(),
11637            )]),
11638        };
11639    }
11640    if let Some(ref local_var_str) = description__niew {
11641        local_var_req_builder = match "multi" {
11642            "multi" => local_var_req_builder.query(
11643                &local_var_str
11644                    .into_iter()
11645                    .map(|p| ("description__niew".to_owned(), p.to_string()))
11646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11647            ),
11648            _ => local_var_req_builder.query(&[(
11649                "description__niew",
11650                &local_var_str
11651                    .into_iter()
11652                    .map(|p| p.to_string())
11653                    .collect::<Vec<String>>()
11654                    .join(",")
11655                    .to_string(),
11656            )]),
11657        };
11658    }
11659    if let Some(ref local_var_str) = description__nisw {
11660        local_var_req_builder = match "multi" {
11661            "multi" => local_var_req_builder.query(
11662                &local_var_str
11663                    .into_iter()
11664                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
11665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11666            ),
11667            _ => local_var_req_builder.query(&[(
11668                "description__nisw",
11669                &local_var_str
11670                    .into_iter()
11671                    .map(|p| p.to_string())
11672                    .collect::<Vec<String>>()
11673                    .join(",")
11674                    .to_string(),
11675            )]),
11676        };
11677    }
11678    if let Some(ref local_var_str) = description__regex {
11679        local_var_req_builder = match "multi" {
11680            "multi" => local_var_req_builder.query(
11681                &local_var_str
11682                    .into_iter()
11683                    .map(|p| ("description__regex".to_owned(), p.to_string()))
11684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11685            ),
11686            _ => local_var_req_builder.query(&[(
11687                "description__regex",
11688                &local_var_str
11689                    .into_iter()
11690                    .map(|p| p.to_string())
11691                    .collect::<Vec<String>>()
11692                    .join(",")
11693                    .to_string(),
11694            )]),
11695        };
11696    }
11697    if let Some(ref local_var_str) = group {
11698        local_var_req_builder = match "multi" {
11699            "multi" => local_var_req_builder.query(
11700                &local_var_str
11701                    .into_iter()
11702                    .map(|p| ("group".to_owned(), p.to_string()))
11703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11704            ),
11705            _ => local_var_req_builder.query(&[(
11706                "group",
11707                &local_var_str
11708                    .into_iter()
11709                    .map(|p| p.to_string())
11710                    .collect::<Vec<String>>()
11711                    .join(",")
11712                    .to_string(),
11713            )]),
11714        };
11715    }
11716    if let Some(ref local_var_str) = group__n {
11717        local_var_req_builder = match "multi" {
11718            "multi" => local_var_req_builder.query(
11719                &local_var_str
11720                    .into_iter()
11721                    .map(|p| ("group__n".to_owned(), p.to_string()))
11722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11723            ),
11724            _ => local_var_req_builder.query(&[(
11725                "group__n",
11726                &local_var_str
11727                    .into_iter()
11728                    .map(|p| p.to_string())
11729                    .collect::<Vec<String>>()
11730                    .join(",")
11731                    .to_string(),
11732            )]),
11733        };
11734    }
11735    if let Some(ref local_var_str) = group_id {
11736        local_var_req_builder = match "multi" {
11737            "multi" => local_var_req_builder.query(
11738                &local_var_str
11739                    .into_iter()
11740                    .map(|p| ("group_id".to_owned(), p.to_string()))
11741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11742            ),
11743            _ => local_var_req_builder.query(&[(
11744                "group_id",
11745                &local_var_str
11746                    .into_iter()
11747                    .map(|p| p.to_string())
11748                    .collect::<Vec<String>>()
11749                    .join(",")
11750                    .to_string(),
11751            )]),
11752        };
11753    }
11754    if let Some(ref local_var_str) = group_id__n {
11755        local_var_req_builder = match "multi" {
11756            "multi" => local_var_req_builder.query(
11757                &local_var_str
11758                    .into_iter()
11759                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
11760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11761            ),
11762            _ => local_var_req_builder.query(&[(
11763                "group_id__n",
11764                &local_var_str
11765                    .into_iter()
11766                    .map(|p| p.to_string())
11767                    .collect::<Vec<String>>()
11768                    .join(",")
11769                    .to_string(),
11770            )]),
11771        };
11772    }
11773    if let Some(ref local_var_str) = id {
11774        local_var_req_builder = match "multi" {
11775            "multi" => local_var_req_builder.query(
11776                &local_var_str
11777                    .into_iter()
11778                    .map(|p| ("id".to_owned(), p.to_string()))
11779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11780            ),
11781            _ => local_var_req_builder.query(&[(
11782                "id",
11783                &local_var_str
11784                    .into_iter()
11785                    .map(|p| p.to_string())
11786                    .collect::<Vec<String>>()
11787                    .join(",")
11788                    .to_string(),
11789            )]),
11790        };
11791    }
11792    if let Some(ref local_var_str) = id__empty {
11793        local_var_req_builder =
11794            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
11795    }
11796    if let Some(ref local_var_str) = id__gt {
11797        local_var_req_builder = match "multi" {
11798            "multi" => local_var_req_builder.query(
11799                &local_var_str
11800                    .into_iter()
11801                    .map(|p| ("id__gt".to_owned(), p.to_string()))
11802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11803            ),
11804            _ => local_var_req_builder.query(&[(
11805                "id__gt",
11806                &local_var_str
11807                    .into_iter()
11808                    .map(|p| p.to_string())
11809                    .collect::<Vec<String>>()
11810                    .join(",")
11811                    .to_string(),
11812            )]),
11813        };
11814    }
11815    if let Some(ref local_var_str) = id__gte {
11816        local_var_req_builder = match "multi" {
11817            "multi" => local_var_req_builder.query(
11818                &local_var_str
11819                    .into_iter()
11820                    .map(|p| ("id__gte".to_owned(), p.to_string()))
11821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11822            ),
11823            _ => local_var_req_builder.query(&[(
11824                "id__gte",
11825                &local_var_str
11826                    .into_iter()
11827                    .map(|p| p.to_string())
11828                    .collect::<Vec<String>>()
11829                    .join(",")
11830                    .to_string(),
11831            )]),
11832        };
11833    }
11834    if let Some(ref local_var_str) = id__lt {
11835        local_var_req_builder = match "multi" {
11836            "multi" => local_var_req_builder.query(
11837                &local_var_str
11838                    .into_iter()
11839                    .map(|p| ("id__lt".to_owned(), p.to_string()))
11840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11841            ),
11842            _ => local_var_req_builder.query(&[(
11843                "id__lt",
11844                &local_var_str
11845                    .into_iter()
11846                    .map(|p| p.to_string())
11847                    .collect::<Vec<String>>()
11848                    .join(",")
11849                    .to_string(),
11850            )]),
11851        };
11852    }
11853    if let Some(ref local_var_str) = id__lte {
11854        local_var_req_builder = match "multi" {
11855            "multi" => local_var_req_builder.query(
11856                &local_var_str
11857                    .into_iter()
11858                    .map(|p| ("id__lte".to_owned(), p.to_string()))
11859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11860            ),
11861            _ => local_var_req_builder.query(&[(
11862                "id__lte",
11863                &local_var_str
11864                    .into_iter()
11865                    .map(|p| p.to_string())
11866                    .collect::<Vec<String>>()
11867                    .join(",")
11868                    .to_string(),
11869            )]),
11870        };
11871    }
11872    if let Some(ref local_var_str) = id__n {
11873        local_var_req_builder = match "multi" {
11874            "multi" => local_var_req_builder.query(
11875                &local_var_str
11876                    .into_iter()
11877                    .map(|p| ("id__n".to_owned(), p.to_string()))
11878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11879            ),
11880            _ => local_var_req_builder.query(&[(
11881                "id__n",
11882                &local_var_str
11883                    .into_iter()
11884                    .map(|p| p.to_string())
11885                    .collect::<Vec<String>>()
11886                    .join(",")
11887                    .to_string(),
11888            )]),
11889        };
11890    }
11891    if let Some(ref local_var_str) = last_updated {
11892        local_var_req_builder = match "multi" {
11893            "multi" => local_var_req_builder.query(
11894                &local_var_str
11895                    .into_iter()
11896                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11898            ),
11899            _ => local_var_req_builder.query(&[(
11900                "last_updated",
11901                &local_var_str
11902                    .into_iter()
11903                    .map(|p| p.to_string())
11904                    .collect::<Vec<String>>()
11905                    .join(",")
11906                    .to_string(),
11907            )]),
11908        };
11909    }
11910    if let Some(ref local_var_str) = last_updated__empty {
11911        local_var_req_builder = match "multi" {
11912            "multi" => local_var_req_builder.query(
11913                &local_var_str
11914                    .into_iter()
11915                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11917            ),
11918            _ => local_var_req_builder.query(&[(
11919                "last_updated__empty",
11920                &local_var_str
11921                    .into_iter()
11922                    .map(|p| p.to_string())
11923                    .collect::<Vec<String>>()
11924                    .join(",")
11925                    .to_string(),
11926            )]),
11927        };
11928    }
11929    if let Some(ref local_var_str) = last_updated__gt {
11930        local_var_req_builder = match "multi" {
11931            "multi" => local_var_req_builder.query(
11932                &local_var_str
11933                    .into_iter()
11934                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11936            ),
11937            _ => local_var_req_builder.query(&[(
11938                "last_updated__gt",
11939                &local_var_str
11940                    .into_iter()
11941                    .map(|p| p.to_string())
11942                    .collect::<Vec<String>>()
11943                    .join(",")
11944                    .to_string(),
11945            )]),
11946        };
11947    }
11948    if let Some(ref local_var_str) = last_updated__gte {
11949        local_var_req_builder = match "multi" {
11950            "multi" => local_var_req_builder.query(
11951                &local_var_str
11952                    .into_iter()
11953                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11955            ),
11956            _ => local_var_req_builder.query(&[(
11957                "last_updated__gte",
11958                &local_var_str
11959                    .into_iter()
11960                    .map(|p| p.to_string())
11961                    .collect::<Vec<String>>()
11962                    .join(",")
11963                    .to_string(),
11964            )]),
11965        };
11966    }
11967    if let Some(ref local_var_str) = last_updated__lt {
11968        local_var_req_builder = match "multi" {
11969            "multi" => local_var_req_builder.query(
11970                &local_var_str
11971                    .into_iter()
11972                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11974            ),
11975            _ => local_var_req_builder.query(&[(
11976                "last_updated__lt",
11977                &local_var_str
11978                    .into_iter()
11979                    .map(|p| p.to_string())
11980                    .collect::<Vec<String>>()
11981                    .join(",")
11982                    .to_string(),
11983            )]),
11984        };
11985    }
11986    if let Some(ref local_var_str) = last_updated__lte {
11987        local_var_req_builder = match "multi" {
11988            "multi" => local_var_req_builder.query(
11989                &local_var_str
11990                    .into_iter()
11991                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11993            ),
11994            _ => local_var_req_builder.query(&[(
11995                "last_updated__lte",
11996                &local_var_str
11997                    .into_iter()
11998                    .map(|p| p.to_string())
11999                    .collect::<Vec<String>>()
12000                    .join(",")
12001                    .to_string(),
12002            )]),
12003        };
12004    }
12005    if let Some(ref local_var_str) = last_updated__n {
12006        local_var_req_builder = match "multi" {
12007            "multi" => local_var_req_builder.query(
12008                &local_var_str
12009                    .into_iter()
12010                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
12011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12012            ),
12013            _ => local_var_req_builder.query(&[(
12014                "last_updated__n",
12015                &local_var_str
12016                    .into_iter()
12017                    .map(|p| p.to_string())
12018                    .collect::<Vec<String>>()
12019                    .join(",")
12020                    .to_string(),
12021            )]),
12022        };
12023    }
12024    if let Some(ref local_var_str) = limit {
12025        local_var_req_builder =
12026            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12027    }
12028    if let Some(ref local_var_str) = modified_by_request {
12029        local_var_req_builder =
12030            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
12031    }
12032    if let Some(ref local_var_str) = name {
12033        local_var_req_builder = match "multi" {
12034            "multi" => local_var_req_builder.query(
12035                &local_var_str
12036                    .into_iter()
12037                    .map(|p| ("name".to_owned(), p.to_string()))
12038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12039            ),
12040            _ => local_var_req_builder.query(&[(
12041                "name",
12042                &local_var_str
12043                    .into_iter()
12044                    .map(|p| p.to_string())
12045                    .collect::<Vec<String>>()
12046                    .join(",")
12047                    .to_string(),
12048            )]),
12049        };
12050    }
12051    if let Some(ref local_var_str) = name__empty {
12052        local_var_req_builder =
12053            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
12054    }
12055    if let Some(ref local_var_str) = name__ic {
12056        local_var_req_builder = match "multi" {
12057            "multi" => local_var_req_builder.query(
12058                &local_var_str
12059                    .into_iter()
12060                    .map(|p| ("name__ic".to_owned(), p.to_string()))
12061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12062            ),
12063            _ => local_var_req_builder.query(&[(
12064                "name__ic",
12065                &local_var_str
12066                    .into_iter()
12067                    .map(|p| p.to_string())
12068                    .collect::<Vec<String>>()
12069                    .join(",")
12070                    .to_string(),
12071            )]),
12072        };
12073    }
12074    if let Some(ref local_var_str) = name__ie {
12075        local_var_req_builder = match "multi" {
12076            "multi" => local_var_req_builder.query(
12077                &local_var_str
12078                    .into_iter()
12079                    .map(|p| ("name__ie".to_owned(), p.to_string()))
12080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12081            ),
12082            _ => local_var_req_builder.query(&[(
12083                "name__ie",
12084                &local_var_str
12085                    .into_iter()
12086                    .map(|p| p.to_string())
12087                    .collect::<Vec<String>>()
12088                    .join(",")
12089                    .to_string(),
12090            )]),
12091        };
12092    }
12093    if let Some(ref local_var_str) = name__iew {
12094        local_var_req_builder = match "multi" {
12095            "multi" => local_var_req_builder.query(
12096                &local_var_str
12097                    .into_iter()
12098                    .map(|p| ("name__iew".to_owned(), p.to_string()))
12099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12100            ),
12101            _ => local_var_req_builder.query(&[(
12102                "name__iew",
12103                &local_var_str
12104                    .into_iter()
12105                    .map(|p| p.to_string())
12106                    .collect::<Vec<String>>()
12107                    .join(",")
12108                    .to_string(),
12109            )]),
12110        };
12111    }
12112    if let Some(ref local_var_str) = name__iregex {
12113        local_var_req_builder = match "multi" {
12114            "multi" => local_var_req_builder.query(
12115                &local_var_str
12116                    .into_iter()
12117                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
12118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12119            ),
12120            _ => local_var_req_builder.query(&[(
12121                "name__iregex",
12122                &local_var_str
12123                    .into_iter()
12124                    .map(|p| p.to_string())
12125                    .collect::<Vec<String>>()
12126                    .join(",")
12127                    .to_string(),
12128            )]),
12129        };
12130    }
12131    if let Some(ref local_var_str) = name__isw {
12132        local_var_req_builder = match "multi" {
12133            "multi" => local_var_req_builder.query(
12134                &local_var_str
12135                    .into_iter()
12136                    .map(|p| ("name__isw".to_owned(), p.to_string()))
12137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12138            ),
12139            _ => local_var_req_builder.query(&[(
12140                "name__isw",
12141                &local_var_str
12142                    .into_iter()
12143                    .map(|p| p.to_string())
12144                    .collect::<Vec<String>>()
12145                    .join(",")
12146                    .to_string(),
12147            )]),
12148        };
12149    }
12150    if let Some(ref local_var_str) = name__n {
12151        local_var_req_builder = match "multi" {
12152            "multi" => local_var_req_builder.query(
12153                &local_var_str
12154                    .into_iter()
12155                    .map(|p| ("name__n".to_owned(), p.to_string()))
12156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12157            ),
12158            _ => local_var_req_builder.query(&[(
12159                "name__n",
12160                &local_var_str
12161                    .into_iter()
12162                    .map(|p| p.to_string())
12163                    .collect::<Vec<String>>()
12164                    .join(",")
12165                    .to_string(),
12166            )]),
12167        };
12168    }
12169    if let Some(ref local_var_str) = name__nic {
12170        local_var_req_builder = match "multi" {
12171            "multi" => local_var_req_builder.query(
12172                &local_var_str
12173                    .into_iter()
12174                    .map(|p| ("name__nic".to_owned(), p.to_string()))
12175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12176            ),
12177            _ => local_var_req_builder.query(&[(
12178                "name__nic",
12179                &local_var_str
12180                    .into_iter()
12181                    .map(|p| p.to_string())
12182                    .collect::<Vec<String>>()
12183                    .join(",")
12184                    .to_string(),
12185            )]),
12186        };
12187    }
12188    if let Some(ref local_var_str) = name__nie {
12189        local_var_req_builder = match "multi" {
12190            "multi" => local_var_req_builder.query(
12191                &local_var_str
12192                    .into_iter()
12193                    .map(|p| ("name__nie".to_owned(), p.to_string()))
12194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12195            ),
12196            _ => local_var_req_builder.query(&[(
12197                "name__nie",
12198                &local_var_str
12199                    .into_iter()
12200                    .map(|p| p.to_string())
12201                    .collect::<Vec<String>>()
12202                    .join(",")
12203                    .to_string(),
12204            )]),
12205        };
12206    }
12207    if let Some(ref local_var_str) = name__niew {
12208        local_var_req_builder = match "multi" {
12209            "multi" => local_var_req_builder.query(
12210                &local_var_str
12211                    .into_iter()
12212                    .map(|p| ("name__niew".to_owned(), p.to_string()))
12213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12214            ),
12215            _ => local_var_req_builder.query(&[(
12216                "name__niew",
12217                &local_var_str
12218                    .into_iter()
12219                    .map(|p| p.to_string())
12220                    .collect::<Vec<String>>()
12221                    .join(",")
12222                    .to_string(),
12223            )]),
12224        };
12225    }
12226    if let Some(ref local_var_str) = name__nisw {
12227        local_var_req_builder = match "multi" {
12228            "multi" => local_var_req_builder.query(
12229                &local_var_str
12230                    .into_iter()
12231                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
12232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12233            ),
12234            _ => local_var_req_builder.query(&[(
12235                "name__nisw",
12236                &local_var_str
12237                    .into_iter()
12238                    .map(|p| p.to_string())
12239                    .collect::<Vec<String>>()
12240                    .join(",")
12241                    .to_string(),
12242            )]),
12243        };
12244    }
12245    if let Some(ref local_var_str) = name__regex {
12246        local_var_req_builder = match "multi" {
12247            "multi" => local_var_req_builder.query(
12248                &local_var_str
12249                    .into_iter()
12250                    .map(|p| ("name__regex".to_owned(), p.to_string()))
12251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12252            ),
12253            _ => local_var_req_builder.query(&[(
12254                "name__regex",
12255                &local_var_str
12256                    .into_iter()
12257                    .map(|p| p.to_string())
12258                    .collect::<Vec<String>>()
12259                    .join(",")
12260                    .to_string(),
12261            )]),
12262        };
12263    }
12264    if let Some(ref local_var_str) = offset {
12265        local_var_req_builder =
12266            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12267    }
12268    if let Some(ref local_var_str) = ordering {
12269        local_var_req_builder =
12270            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
12271    }
12272    if let Some(ref local_var_str) = owner {
12273        local_var_req_builder = match "multi" {
12274            "multi" => local_var_req_builder.query(
12275                &local_var_str
12276                    .into_iter()
12277                    .map(|p| ("owner".to_owned(), p.to_string()))
12278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12279            ),
12280            _ => local_var_req_builder.query(&[(
12281                "owner",
12282                &local_var_str
12283                    .into_iter()
12284                    .map(|p| p.to_string())
12285                    .collect::<Vec<String>>()
12286                    .join(",")
12287                    .to_string(),
12288            )]),
12289        };
12290    }
12291    if let Some(ref local_var_str) = owner__n {
12292        local_var_req_builder = match "multi" {
12293            "multi" => local_var_req_builder.query(
12294                &local_var_str
12295                    .into_iter()
12296                    .map(|p| ("owner__n".to_owned(), p.to_string()))
12297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12298            ),
12299            _ => local_var_req_builder.query(&[(
12300                "owner__n",
12301                &local_var_str
12302                    .into_iter()
12303                    .map(|p| p.to_string())
12304                    .collect::<Vec<String>>()
12305                    .join(",")
12306                    .to_string(),
12307            )]),
12308        };
12309    }
12310    if let Some(ref local_var_str) = owner_group {
12311        local_var_req_builder = match "multi" {
12312            "multi" => local_var_req_builder.query(
12313                &local_var_str
12314                    .into_iter()
12315                    .map(|p| ("owner_group".to_owned(), p.to_string()))
12316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12317            ),
12318            _ => local_var_req_builder.query(&[(
12319                "owner_group",
12320                &local_var_str
12321                    .into_iter()
12322                    .map(|p| p.to_string())
12323                    .collect::<Vec<String>>()
12324                    .join(",")
12325                    .to_string(),
12326            )]),
12327        };
12328    }
12329    if let Some(ref local_var_str) = owner_group__n {
12330        local_var_req_builder = match "multi" {
12331            "multi" => local_var_req_builder.query(
12332                &local_var_str
12333                    .into_iter()
12334                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
12335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12336            ),
12337            _ => local_var_req_builder.query(&[(
12338                "owner_group__n",
12339                &local_var_str
12340                    .into_iter()
12341                    .map(|p| p.to_string())
12342                    .collect::<Vec<String>>()
12343                    .join(",")
12344                    .to_string(),
12345            )]),
12346        };
12347    }
12348    if let Some(ref local_var_str) = owner_group_id {
12349        local_var_req_builder = match "multi" {
12350            "multi" => local_var_req_builder.query(
12351                &local_var_str
12352                    .into_iter()
12353                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
12354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12355            ),
12356            _ => local_var_req_builder.query(&[(
12357                "owner_group_id",
12358                &local_var_str
12359                    .into_iter()
12360                    .map(|p| p.to_string())
12361                    .collect::<Vec<String>>()
12362                    .join(",")
12363                    .to_string(),
12364            )]),
12365        };
12366    }
12367    if let Some(ref local_var_str) = owner_group_id__n {
12368        local_var_req_builder = match "multi" {
12369            "multi" => local_var_req_builder.query(
12370                &local_var_str
12371                    .into_iter()
12372                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
12373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12374            ),
12375            _ => local_var_req_builder.query(&[(
12376                "owner_group_id__n",
12377                &local_var_str
12378                    .into_iter()
12379                    .map(|p| p.to_string())
12380                    .collect::<Vec<String>>()
12381                    .join(",")
12382                    .to_string(),
12383            )]),
12384        };
12385    }
12386    if let Some(ref local_var_str) = owner_id {
12387        local_var_req_builder = match "multi" {
12388            "multi" => local_var_req_builder.query(
12389                &local_var_str
12390                    .into_iter()
12391                    .map(|p| ("owner_id".to_owned(), p.to_string()))
12392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12393            ),
12394            _ => local_var_req_builder.query(&[(
12395                "owner_id",
12396                &local_var_str
12397                    .into_iter()
12398                    .map(|p| p.to_string())
12399                    .collect::<Vec<String>>()
12400                    .join(",")
12401                    .to_string(),
12402            )]),
12403        };
12404    }
12405    if let Some(ref local_var_str) = owner_id__n {
12406        local_var_req_builder = match "multi" {
12407            "multi" => local_var_req_builder.query(
12408                &local_var_str
12409                    .into_iter()
12410                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
12411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12412            ),
12413            _ => local_var_req_builder.query(&[(
12414                "owner_id__n",
12415                &local_var_str
12416                    .into_iter()
12417                    .map(|p| p.to_string())
12418                    .collect::<Vec<String>>()
12419                    .join(",")
12420                    .to_string(),
12421            )]),
12422        };
12423    }
12424    if let Some(ref local_var_str) = q {
12425        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12426    }
12427    if let Some(ref local_var_str) = slug {
12428        local_var_req_builder = match "multi" {
12429            "multi" => local_var_req_builder.query(
12430                &local_var_str
12431                    .into_iter()
12432                    .map(|p| ("slug".to_owned(), p.to_string()))
12433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12434            ),
12435            _ => local_var_req_builder.query(&[(
12436                "slug",
12437                &local_var_str
12438                    .into_iter()
12439                    .map(|p| p.to_string())
12440                    .collect::<Vec<String>>()
12441                    .join(",")
12442                    .to_string(),
12443            )]),
12444        };
12445    }
12446    if let Some(ref local_var_str) = slug__empty {
12447        local_var_req_builder =
12448            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
12449    }
12450    if let Some(ref local_var_str) = slug__ic {
12451        local_var_req_builder = match "multi" {
12452            "multi" => local_var_req_builder.query(
12453                &local_var_str
12454                    .into_iter()
12455                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
12456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12457            ),
12458            _ => local_var_req_builder.query(&[(
12459                "slug__ic",
12460                &local_var_str
12461                    .into_iter()
12462                    .map(|p| p.to_string())
12463                    .collect::<Vec<String>>()
12464                    .join(",")
12465                    .to_string(),
12466            )]),
12467        };
12468    }
12469    if let Some(ref local_var_str) = slug__ie {
12470        local_var_req_builder = match "multi" {
12471            "multi" => local_var_req_builder.query(
12472                &local_var_str
12473                    .into_iter()
12474                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
12475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12476            ),
12477            _ => local_var_req_builder.query(&[(
12478                "slug__ie",
12479                &local_var_str
12480                    .into_iter()
12481                    .map(|p| p.to_string())
12482                    .collect::<Vec<String>>()
12483                    .join(",")
12484                    .to_string(),
12485            )]),
12486        };
12487    }
12488    if let Some(ref local_var_str) = slug__iew {
12489        local_var_req_builder = match "multi" {
12490            "multi" => local_var_req_builder.query(
12491                &local_var_str
12492                    .into_iter()
12493                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
12494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12495            ),
12496            _ => local_var_req_builder.query(&[(
12497                "slug__iew",
12498                &local_var_str
12499                    .into_iter()
12500                    .map(|p| p.to_string())
12501                    .collect::<Vec<String>>()
12502                    .join(",")
12503                    .to_string(),
12504            )]),
12505        };
12506    }
12507    if let Some(ref local_var_str) = slug__iregex {
12508        local_var_req_builder = match "multi" {
12509            "multi" => local_var_req_builder.query(
12510                &local_var_str
12511                    .into_iter()
12512                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
12513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12514            ),
12515            _ => local_var_req_builder.query(&[(
12516                "slug__iregex",
12517                &local_var_str
12518                    .into_iter()
12519                    .map(|p| p.to_string())
12520                    .collect::<Vec<String>>()
12521                    .join(",")
12522                    .to_string(),
12523            )]),
12524        };
12525    }
12526    if let Some(ref local_var_str) = slug__isw {
12527        local_var_req_builder = match "multi" {
12528            "multi" => local_var_req_builder.query(
12529                &local_var_str
12530                    .into_iter()
12531                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
12532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12533            ),
12534            _ => local_var_req_builder.query(&[(
12535                "slug__isw",
12536                &local_var_str
12537                    .into_iter()
12538                    .map(|p| p.to_string())
12539                    .collect::<Vec<String>>()
12540                    .join(",")
12541                    .to_string(),
12542            )]),
12543        };
12544    }
12545    if let Some(ref local_var_str) = slug__n {
12546        local_var_req_builder = match "multi" {
12547            "multi" => local_var_req_builder.query(
12548                &local_var_str
12549                    .into_iter()
12550                    .map(|p| ("slug__n".to_owned(), p.to_string()))
12551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12552            ),
12553            _ => local_var_req_builder.query(&[(
12554                "slug__n",
12555                &local_var_str
12556                    .into_iter()
12557                    .map(|p| p.to_string())
12558                    .collect::<Vec<String>>()
12559                    .join(",")
12560                    .to_string(),
12561            )]),
12562        };
12563    }
12564    if let Some(ref local_var_str) = slug__nic {
12565        local_var_req_builder = match "multi" {
12566            "multi" => local_var_req_builder.query(
12567                &local_var_str
12568                    .into_iter()
12569                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
12570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12571            ),
12572            _ => local_var_req_builder.query(&[(
12573                "slug__nic",
12574                &local_var_str
12575                    .into_iter()
12576                    .map(|p| p.to_string())
12577                    .collect::<Vec<String>>()
12578                    .join(",")
12579                    .to_string(),
12580            )]),
12581        };
12582    }
12583    if let Some(ref local_var_str) = slug__nie {
12584        local_var_req_builder = match "multi" {
12585            "multi" => local_var_req_builder.query(
12586                &local_var_str
12587                    .into_iter()
12588                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
12589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12590            ),
12591            _ => local_var_req_builder.query(&[(
12592                "slug__nie",
12593                &local_var_str
12594                    .into_iter()
12595                    .map(|p| p.to_string())
12596                    .collect::<Vec<String>>()
12597                    .join(",")
12598                    .to_string(),
12599            )]),
12600        };
12601    }
12602    if let Some(ref local_var_str) = slug__niew {
12603        local_var_req_builder = match "multi" {
12604            "multi" => local_var_req_builder.query(
12605                &local_var_str
12606                    .into_iter()
12607                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
12608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12609            ),
12610            _ => local_var_req_builder.query(&[(
12611                "slug__niew",
12612                &local_var_str
12613                    .into_iter()
12614                    .map(|p| p.to_string())
12615                    .collect::<Vec<String>>()
12616                    .join(",")
12617                    .to_string(),
12618            )]),
12619        };
12620    }
12621    if let Some(ref local_var_str) = slug__nisw {
12622        local_var_req_builder = match "multi" {
12623            "multi" => local_var_req_builder.query(
12624                &local_var_str
12625                    .into_iter()
12626                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
12627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12628            ),
12629            _ => local_var_req_builder.query(&[(
12630                "slug__nisw",
12631                &local_var_str
12632                    .into_iter()
12633                    .map(|p| p.to_string())
12634                    .collect::<Vec<String>>()
12635                    .join(",")
12636                    .to_string(),
12637            )]),
12638        };
12639    }
12640    if let Some(ref local_var_str) = slug__regex {
12641        local_var_req_builder = match "multi" {
12642            "multi" => local_var_req_builder.query(
12643                &local_var_str
12644                    .into_iter()
12645                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
12646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12647            ),
12648            _ => local_var_req_builder.query(&[(
12649                "slug__regex",
12650                &local_var_str
12651                    .into_iter()
12652                    .map(|p| p.to_string())
12653                    .collect::<Vec<String>>()
12654                    .join(",")
12655                    .to_string(),
12656            )]),
12657        };
12658    }
12659    if let Some(ref local_var_str) = start {
12660        local_var_req_builder =
12661            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
12662    }
12663    if let Some(ref local_var_str) = tag {
12664        local_var_req_builder = match "multi" {
12665            "multi" => local_var_req_builder.query(
12666                &local_var_str
12667                    .into_iter()
12668                    .map(|p| ("tag".to_owned(), p.to_string()))
12669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12670            ),
12671            _ => local_var_req_builder.query(&[(
12672                "tag",
12673                &local_var_str
12674                    .into_iter()
12675                    .map(|p| p.to_string())
12676                    .collect::<Vec<String>>()
12677                    .join(",")
12678                    .to_string(),
12679            )]),
12680        };
12681    }
12682    if let Some(ref local_var_str) = tag__n {
12683        local_var_req_builder = match "multi" {
12684            "multi" => local_var_req_builder.query(
12685                &local_var_str
12686                    .into_iter()
12687                    .map(|p| ("tag__n".to_owned(), p.to_string()))
12688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12689            ),
12690            _ => local_var_req_builder.query(&[(
12691                "tag__n",
12692                &local_var_str
12693                    .into_iter()
12694                    .map(|p| p.to_string())
12695                    .collect::<Vec<String>>()
12696                    .join(",")
12697                    .to_string(),
12698            )]),
12699        };
12700    }
12701    if let Some(ref local_var_str) = tag_id {
12702        local_var_req_builder = match "multi" {
12703            "multi" => local_var_req_builder.query(
12704                &local_var_str
12705                    .into_iter()
12706                    .map(|p| ("tag_id".to_owned(), p.to_string()))
12707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12708            ),
12709            _ => local_var_req_builder.query(&[(
12710                "tag_id",
12711                &local_var_str
12712                    .into_iter()
12713                    .map(|p| p.to_string())
12714                    .collect::<Vec<String>>()
12715                    .join(",")
12716                    .to_string(),
12717            )]),
12718        };
12719    }
12720    if let Some(ref local_var_str) = tag_id__n {
12721        local_var_req_builder = match "multi" {
12722            "multi" => local_var_req_builder.query(
12723                &local_var_str
12724                    .into_iter()
12725                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
12726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12727            ),
12728            _ => local_var_req_builder.query(&[(
12729                "tag_id__n",
12730                &local_var_str
12731                    .into_iter()
12732                    .map(|p| p.to_string())
12733                    .collect::<Vec<String>>()
12734                    .join(",")
12735                    .to_string(),
12736            )]),
12737        };
12738    }
12739    if let Some(ref local_var_str) = updated_by_request {
12740        local_var_req_builder =
12741            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
12742    }
12743    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12744        local_var_req_builder =
12745            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12746    }
12747    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12748        let local_var_key = local_var_apikey.key.clone();
12749        let local_var_value = match local_var_apikey.prefix {
12750            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12751            None => local_var_key,
12752        };
12753        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12754    };
12755
12756    let local_var_req = local_var_req_builder.build()?;
12757    let local_var_resp = local_var_client.execute(local_var_req).await?;
12758
12759    let local_var_status = local_var_resp.status();
12760    let local_var_content = local_var_resp.text().await?;
12761
12762    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12763        serde_json::from_str(&local_var_content).map_err(Error::from)
12764    } else {
12765        let local_var_entity: Option<TenancyTenantsListError> =
12766            serde_json::from_str(&local_var_content).ok();
12767        let local_var_error = ResponseContent {
12768            status: local_var_status,
12769            content: local_var_content,
12770            entity: local_var_entity,
12771        };
12772        Err(Error::ResponseError(local_var_error))
12773    }
12774}
12775
12776/// Patch a tenant object.
12777pub async fn tenancy_tenants_partial_update(
12778    configuration: &configuration::Configuration,
12779    id: i32,
12780    patched_tenant_request: Option<crate::models::PatchedTenantRequest>,
12781) -> Result<crate::models::Tenant, Error<TenancyTenantsPartialUpdateError>> {
12782    let local_var_configuration = configuration;
12783
12784    let local_var_client = &local_var_configuration.client;
12785
12786    let local_var_uri_str = format!(
12787        "{}/api/tenancy/tenants/{id}/",
12788        local_var_configuration.base_path,
12789        id = id
12790    );
12791    let mut local_var_req_builder =
12792        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12793
12794    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12795        local_var_req_builder =
12796            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12797    }
12798    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12799        let local_var_key = local_var_apikey.key.clone();
12800        let local_var_value = match local_var_apikey.prefix {
12801            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12802            None => local_var_key,
12803        };
12804        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12805    };
12806    local_var_req_builder = local_var_req_builder.json(&patched_tenant_request);
12807
12808    let local_var_req = local_var_req_builder.build()?;
12809    let local_var_resp = local_var_client.execute(local_var_req).await?;
12810
12811    let local_var_status = local_var_resp.status();
12812    let local_var_content = local_var_resp.text().await?;
12813
12814    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12815        serde_json::from_str(&local_var_content).map_err(Error::from)
12816    } else {
12817        let local_var_entity: Option<TenancyTenantsPartialUpdateError> =
12818            serde_json::from_str(&local_var_content).ok();
12819        let local_var_error = ResponseContent {
12820            status: local_var_status,
12821            content: local_var_content,
12822            entity: local_var_entity,
12823        };
12824        Err(Error::ResponseError(local_var_error))
12825    }
12826}
12827
12828/// Get a tenant object.
12829pub async fn tenancy_tenants_retrieve(
12830    configuration: &configuration::Configuration,
12831    id: i32,
12832) -> Result<crate::models::Tenant, Error<TenancyTenantsRetrieveError>> {
12833    let local_var_configuration = configuration;
12834
12835    let local_var_client = &local_var_configuration.client;
12836
12837    let local_var_uri_str = format!(
12838        "{}/api/tenancy/tenants/{id}/",
12839        local_var_configuration.base_path,
12840        id = id
12841    );
12842    let mut local_var_req_builder =
12843        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12844
12845    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12846        local_var_req_builder =
12847            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12848    }
12849    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12850        let local_var_key = local_var_apikey.key.clone();
12851        let local_var_value = match local_var_apikey.prefix {
12852            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12853            None => local_var_key,
12854        };
12855        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12856    };
12857
12858    let local_var_req = local_var_req_builder.build()?;
12859    let local_var_resp = local_var_client.execute(local_var_req).await?;
12860
12861    let local_var_status = local_var_resp.status();
12862    let local_var_content = local_var_resp.text().await?;
12863
12864    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12865        serde_json::from_str(&local_var_content).map_err(Error::from)
12866    } else {
12867        let local_var_entity: Option<TenancyTenantsRetrieveError> =
12868            serde_json::from_str(&local_var_content).ok();
12869        let local_var_error = ResponseContent {
12870            status: local_var_status,
12871            content: local_var_content,
12872            entity: local_var_entity,
12873        };
12874        Err(Error::ResponseError(local_var_error))
12875    }
12876}
12877
12878/// Put a tenant object.
12879pub async fn tenancy_tenants_update(
12880    configuration: &configuration::Configuration,
12881    id: i32,
12882    tenant_request: crate::models::TenantRequest,
12883) -> Result<crate::models::Tenant, Error<TenancyTenantsUpdateError>> {
12884    let local_var_configuration = configuration;
12885
12886    let local_var_client = &local_var_configuration.client;
12887
12888    let local_var_uri_str = format!(
12889        "{}/api/tenancy/tenants/{id}/",
12890        local_var_configuration.base_path,
12891        id = id
12892    );
12893    let mut local_var_req_builder =
12894        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12895
12896    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12897        local_var_req_builder =
12898            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12899    }
12900    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12901        let local_var_key = local_var_apikey.key.clone();
12902        let local_var_value = match local_var_apikey.prefix {
12903            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12904            None => local_var_key,
12905        };
12906        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12907    };
12908    local_var_req_builder = local_var_req_builder.json(&tenant_request);
12909
12910    let local_var_req = local_var_req_builder.build()?;
12911    let local_var_resp = local_var_client.execute(local_var_req).await?;
12912
12913    let local_var_status = local_var_resp.status();
12914    let local_var_content = local_var_resp.text().await?;
12915
12916    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12917        serde_json::from_str(&local_var_content).map_err(Error::from)
12918    } else {
12919        let local_var_entity: Option<TenancyTenantsUpdateError> =
12920            serde_json::from_str(&local_var_content).ok();
12921        let local_var_error = ResponseContent {
12922            status: local_var_status,
12923            content: local_var_content,
12924            entity: local_var_entity,
12925        };
12926        Err(Error::ResponseError(local_var_error))
12927    }
12928}
netbox_openapi/apis/tenancy_api.rs

netbox_openapi/apis/
tenancy_api.rs
