netbox_openapi/apis/
users_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 [`users_config_retrieve`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum UsersConfigRetrieveError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`users_groups_bulk_destroy`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum UsersGroupsBulkDestroyError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`users_groups_bulk_partial_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum UsersGroupsBulkPartialUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`users_groups_bulk_update`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum UsersGroupsBulkUpdateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`users_groups_create`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum UsersGroupsCreateError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`users_groups_destroy`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum UsersGroupsDestroyError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`users_groups_list`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum UsersGroupsListError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`users_groups_partial_update`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum UsersGroupsPartialUpdateError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`users_groups_retrieve`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum UsersGroupsRetrieveError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`users_groups_update`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum UsersGroupsUpdateError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`users_owner_groups_bulk_destroy`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum UsersOwnerGroupsBulkDestroyError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`users_owner_groups_bulk_partial_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum UsersOwnerGroupsBulkPartialUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`users_owner_groups_bulk_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum UsersOwnerGroupsBulkUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`users_owner_groups_create`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum UsersOwnerGroupsCreateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`users_owner_groups_destroy`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum UsersOwnerGroupsDestroyError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`users_owner_groups_list`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum UsersOwnerGroupsListError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`users_owner_groups_partial_update`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum UsersOwnerGroupsPartialUpdateError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`users_owner_groups_retrieve`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum UsersOwnerGroupsRetrieveError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`users_owner_groups_update`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum UsersOwnerGroupsUpdateError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`users_owners_bulk_destroy`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum UsersOwnersBulkDestroyError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`users_owners_bulk_partial_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum UsersOwnersBulkPartialUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`users_owners_bulk_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum UsersOwnersBulkUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`users_owners_create`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum UsersOwnersCreateError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`users_owners_destroy`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum UsersOwnersDestroyError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`users_owners_list`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum UsersOwnersListError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`users_owners_partial_update`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum UsersOwnersPartialUpdateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`users_owners_retrieve`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum UsersOwnersRetrieveError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`users_owners_update`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum UsersOwnersUpdateError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`users_permissions_bulk_destroy`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum UsersPermissionsBulkDestroyError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`users_permissions_bulk_partial_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum UsersPermissionsBulkPartialUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`users_permissions_bulk_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum UsersPermissionsBulkUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`users_permissions_create`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum UsersPermissionsCreateError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`users_permissions_destroy`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum UsersPermissionsDestroyError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`users_permissions_list`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum UsersPermissionsListError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`users_permissions_partial_update`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum UsersPermissionsPartialUpdateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`users_permissions_retrieve`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum UsersPermissionsRetrieveError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`users_permissions_update`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum UsersPermissionsUpdateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`users_tokens_bulk_destroy`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum UsersTokensBulkDestroyError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`users_tokens_bulk_partial_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum UsersTokensBulkPartialUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`users_tokens_bulk_update`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum UsersTokensBulkUpdateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`users_tokens_create`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum UsersTokensCreateError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`users_tokens_destroy`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum UsersTokensDestroyError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`users_tokens_list`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum UsersTokensListError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`users_tokens_partial_update`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum UsersTokensPartialUpdateError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`users_tokens_provision_create`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum UsersTokensProvisionCreateError {
328    Status401(::std::collections::HashMap<String, serde_json::Value>),
329    UnknownValue(serde_json::Value),
330}
331
332/// struct for typed errors of method [`users_tokens_retrieve`]
333#[derive(Debug, Clone, Serialize, Deserialize)]
334#[serde(untagged)]
335pub enum UsersTokensRetrieveError {
336    UnknownValue(serde_json::Value),
337}
338
339/// struct for typed errors of method [`users_tokens_update`]
340#[derive(Debug, Clone, Serialize, Deserialize)]
341#[serde(untagged)]
342pub enum UsersTokensUpdateError {
343    UnknownValue(serde_json::Value),
344}
345
346/// struct for typed errors of method [`users_users_bulk_destroy`]
347#[derive(Debug, Clone, Serialize, Deserialize)]
348#[serde(untagged)]
349pub enum UsersUsersBulkDestroyError {
350    UnknownValue(serde_json::Value),
351}
352
353/// struct for typed errors of method [`users_users_bulk_partial_update`]
354#[derive(Debug, Clone, Serialize, Deserialize)]
355#[serde(untagged)]
356pub enum UsersUsersBulkPartialUpdateError {
357    UnknownValue(serde_json::Value),
358}
359
360/// struct for typed errors of method [`users_users_bulk_update`]
361#[derive(Debug, Clone, Serialize, Deserialize)]
362#[serde(untagged)]
363pub enum UsersUsersBulkUpdateError {
364    UnknownValue(serde_json::Value),
365}
366
367/// struct for typed errors of method [`users_users_create`]
368#[derive(Debug, Clone, Serialize, Deserialize)]
369#[serde(untagged)]
370pub enum UsersUsersCreateError {
371    UnknownValue(serde_json::Value),
372}
373
374/// struct for typed errors of method [`users_users_destroy`]
375#[derive(Debug, Clone, Serialize, Deserialize)]
376#[serde(untagged)]
377pub enum UsersUsersDestroyError {
378    UnknownValue(serde_json::Value),
379}
380
381/// struct for typed errors of method [`users_users_list`]
382#[derive(Debug, Clone, Serialize, Deserialize)]
383#[serde(untagged)]
384pub enum UsersUsersListError {
385    UnknownValue(serde_json::Value),
386}
387
388/// struct for typed errors of method [`users_users_partial_update`]
389#[derive(Debug, Clone, Serialize, Deserialize)]
390#[serde(untagged)]
391pub enum UsersUsersPartialUpdateError {
392    UnknownValue(serde_json::Value),
393}
394
395/// struct for typed errors of method [`users_users_retrieve`]
396#[derive(Debug, Clone, Serialize, Deserialize)]
397#[serde(untagged)]
398pub enum UsersUsersRetrieveError {
399    UnknownValue(serde_json::Value),
400}
401
402/// struct for typed errors of method [`users_users_update`]
403#[derive(Debug, Clone, Serialize, Deserialize)]
404#[serde(untagged)]
405pub enum UsersUsersUpdateError {
406    UnknownValue(serde_json::Value),
407}
408
409/// An API endpoint via which a user can update his or her own UserConfig data (but no one else's).
410pub async fn users_config_retrieve(
411    configuration: &configuration::Configuration,
412) -> Result<::std::collections::HashMap<String, serde_json::Value>, Error<UsersConfigRetrieveError>>
413{
414    let local_var_configuration = configuration;
415
416    let local_var_client = &local_var_configuration.client;
417
418    let local_var_uri_str = format!("{}/api/users/config/", local_var_configuration.base_path);
419    let mut local_var_req_builder =
420        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
421
422    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
423        local_var_req_builder =
424            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
425    }
426    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
427        let local_var_key = local_var_apikey.key.clone();
428        let local_var_value = match local_var_apikey.prefix {
429            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
430            None => local_var_key,
431        };
432        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
433    };
434
435    let local_var_req = local_var_req_builder.build()?;
436    let local_var_resp = local_var_client.execute(local_var_req).await?;
437
438    let local_var_status = local_var_resp.status();
439    let local_var_content = local_var_resp.text().await?;
440
441    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
442        serde_json::from_str(&local_var_content).map_err(Error::from)
443    } else {
444        let local_var_entity: Option<UsersConfigRetrieveError> =
445            serde_json::from_str(&local_var_content).ok();
446        let local_var_error = ResponseContent {
447            status: local_var_status,
448            content: local_var_content,
449            entity: local_var_entity,
450        };
451        Err(Error::ResponseError(local_var_error))
452    }
453}
454
455/// Delete a list of group objects.
456pub async fn users_groups_bulk_destroy(
457    configuration: &configuration::Configuration,
458    group_request: Vec<crate::models::GroupRequest>,
459) -> Result<(), Error<UsersGroupsBulkDestroyError>> {
460    let local_var_configuration = configuration;
461
462    let local_var_client = &local_var_configuration.client;
463
464    let local_var_uri_str = format!("{}/api/users/groups/", local_var_configuration.base_path);
465    let mut local_var_req_builder =
466        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
467
468    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
469        local_var_req_builder =
470            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
471    }
472    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
473        let local_var_key = local_var_apikey.key.clone();
474        let local_var_value = match local_var_apikey.prefix {
475            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
476            None => local_var_key,
477        };
478        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
479    };
480    local_var_req_builder = local_var_req_builder.json(&group_request);
481
482    let local_var_req = local_var_req_builder.build()?;
483    let local_var_resp = local_var_client.execute(local_var_req).await?;
484
485    let local_var_status = local_var_resp.status();
486    let local_var_content = local_var_resp.text().await?;
487
488    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
489        Ok(())
490    } else {
491        let local_var_entity: Option<UsersGroupsBulkDestroyError> =
492            serde_json::from_str(&local_var_content).ok();
493        let local_var_error = ResponseContent {
494            status: local_var_status,
495            content: local_var_content,
496            entity: local_var_entity,
497        };
498        Err(Error::ResponseError(local_var_error))
499    }
500}
501
502/// Patch a list of group objects.
503pub async fn users_groups_bulk_partial_update(
504    configuration: &configuration::Configuration,
505    group_request: Vec<crate::models::GroupRequest>,
506) -> Result<Vec<crate::models::Group>, Error<UsersGroupsBulkPartialUpdateError>> {
507    let local_var_configuration = configuration;
508
509    let local_var_client = &local_var_configuration.client;
510
511    let local_var_uri_str = format!("{}/api/users/groups/", local_var_configuration.base_path);
512    let mut local_var_req_builder =
513        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
514
515    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
516        local_var_req_builder =
517            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
518    }
519    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
520        let local_var_key = local_var_apikey.key.clone();
521        let local_var_value = match local_var_apikey.prefix {
522            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
523            None => local_var_key,
524        };
525        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
526    };
527    local_var_req_builder = local_var_req_builder.json(&group_request);
528
529    let local_var_req = local_var_req_builder.build()?;
530    let local_var_resp = local_var_client.execute(local_var_req).await?;
531
532    let local_var_status = local_var_resp.status();
533    let local_var_content = local_var_resp.text().await?;
534
535    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
536        serde_json::from_str(&local_var_content).map_err(Error::from)
537    } else {
538        let local_var_entity: Option<UsersGroupsBulkPartialUpdateError> =
539            serde_json::from_str(&local_var_content).ok();
540        let local_var_error = ResponseContent {
541            status: local_var_status,
542            content: local_var_content,
543            entity: local_var_entity,
544        };
545        Err(Error::ResponseError(local_var_error))
546    }
547}
548
549/// Put a list of group objects.
550pub async fn users_groups_bulk_update(
551    configuration: &configuration::Configuration,
552    group_request: Vec<crate::models::GroupRequest>,
553) -> Result<Vec<crate::models::Group>, Error<UsersGroupsBulkUpdateError>> {
554    let local_var_configuration = configuration;
555
556    let local_var_client = &local_var_configuration.client;
557
558    let local_var_uri_str = format!("{}/api/users/groups/", local_var_configuration.base_path);
559    let mut local_var_req_builder =
560        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
561
562    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
563        local_var_req_builder =
564            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
565    }
566    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
567        let local_var_key = local_var_apikey.key.clone();
568        let local_var_value = match local_var_apikey.prefix {
569            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
570            None => local_var_key,
571        };
572        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
573    };
574    local_var_req_builder = local_var_req_builder.json(&group_request);
575
576    let local_var_req = local_var_req_builder.build()?;
577    let local_var_resp = local_var_client.execute(local_var_req).await?;
578
579    let local_var_status = local_var_resp.status();
580    let local_var_content = local_var_resp.text().await?;
581
582    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
583        serde_json::from_str(&local_var_content).map_err(Error::from)
584    } else {
585        let local_var_entity: Option<UsersGroupsBulkUpdateError> =
586            serde_json::from_str(&local_var_content).ok();
587        let local_var_error = ResponseContent {
588            status: local_var_status,
589            content: local_var_content,
590            entity: local_var_entity,
591        };
592        Err(Error::ResponseError(local_var_error))
593    }
594}
595
596/// Post a list of group objects.
597pub async fn users_groups_create(
598    configuration: &configuration::Configuration,
599    users_groups_create_request: crate::models::UsersGroupsCreateRequest,
600) -> Result<crate::models::Group, Error<UsersGroupsCreateError>> {
601    let local_var_configuration = configuration;
602
603    let local_var_client = &local_var_configuration.client;
604
605    let local_var_uri_str = format!("{}/api/users/groups/", local_var_configuration.base_path);
606    let mut local_var_req_builder =
607        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
608
609    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
610        local_var_req_builder =
611            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
612    }
613    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
614        let local_var_key = local_var_apikey.key.clone();
615        let local_var_value = match local_var_apikey.prefix {
616            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
617            None => local_var_key,
618        };
619        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
620    };
621    local_var_req_builder = local_var_req_builder.json(&users_groups_create_request);
622
623    let local_var_req = local_var_req_builder.build()?;
624    let local_var_resp = local_var_client.execute(local_var_req).await?;
625
626    let local_var_status = local_var_resp.status();
627    let local_var_content = local_var_resp.text().await?;
628
629    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
630        serde_json::from_str(&local_var_content).map_err(Error::from)
631    } else {
632        let local_var_entity: Option<UsersGroupsCreateError> =
633            serde_json::from_str(&local_var_content).ok();
634        let local_var_error = ResponseContent {
635            status: local_var_status,
636            content: local_var_content,
637            entity: local_var_entity,
638        };
639        Err(Error::ResponseError(local_var_error))
640    }
641}
642
643/// Delete a group object.
644pub async fn users_groups_destroy(
645    configuration: &configuration::Configuration,
646    id: i32,
647) -> Result<(), Error<UsersGroupsDestroyError>> {
648    let local_var_configuration = configuration;
649
650    let local_var_client = &local_var_configuration.client;
651
652    let local_var_uri_str = format!(
653        "{}/api/users/groups/{id}/",
654        local_var_configuration.base_path,
655        id = id
656    );
657    let mut local_var_req_builder =
658        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
659
660    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
661        local_var_req_builder =
662            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
663    }
664    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
665        let local_var_key = local_var_apikey.key.clone();
666        let local_var_value = match local_var_apikey.prefix {
667            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
668            None => local_var_key,
669        };
670        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
671    };
672
673    let local_var_req = local_var_req_builder.build()?;
674    let local_var_resp = local_var_client.execute(local_var_req).await?;
675
676    let local_var_status = local_var_resp.status();
677    let local_var_content = local_var_resp.text().await?;
678
679    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
680        Ok(())
681    } else {
682        let local_var_entity: Option<UsersGroupsDestroyError> =
683            serde_json::from_str(&local_var_content).ok();
684        let local_var_error = ResponseContent {
685            status: local_var_status,
686            content: local_var_content,
687            entity: local_var_entity,
688        };
689        Err(Error::ResponseError(local_var_error))
690    }
691}
692
693/// Get a list of group objects.
694pub async fn users_groups_list(
695    configuration: &configuration::Configuration,
696    description: Option<Vec<String>>,
697    description__empty: Option<bool>,
698    description__ic: Option<Vec<String>>,
699    description__ie: Option<Vec<String>>,
700    description__iew: Option<Vec<String>>,
701    description__iregex: Option<Vec<String>>,
702    description__isw: Option<Vec<String>>,
703    description__n: Option<Vec<String>>,
704    description__nic: Option<Vec<String>>,
705    description__nie: Option<Vec<String>>,
706    description__niew: Option<Vec<String>>,
707    description__nisw: Option<Vec<String>>,
708    description__regex: Option<Vec<String>>,
709    id: Option<Vec<i32>>,
710    id__empty: Option<bool>,
711    id__gt: Option<Vec<i32>>,
712    id__gte: Option<Vec<i32>>,
713    id__lt: Option<Vec<i32>>,
714    id__lte: Option<Vec<i32>>,
715    id__n: Option<Vec<i32>>,
716    limit: Option<i32>,
717    name: Option<Vec<String>>,
718    name__empty: Option<bool>,
719    name__ic: Option<Vec<String>>,
720    name__ie: Option<Vec<String>>,
721    name__iew: Option<Vec<String>>,
722    name__iregex: Option<Vec<String>>,
723    name__isw: Option<Vec<String>>,
724    name__n: Option<Vec<String>>,
725    name__nic: Option<Vec<String>>,
726    name__nie: Option<Vec<String>>,
727    name__niew: Option<Vec<String>>,
728    name__nisw: Option<Vec<String>>,
729    name__regex: Option<Vec<String>>,
730    notification_group_id: Option<Vec<i32>>,
731    notification_group_id__n: Option<Vec<i32>>,
732    offset: Option<i32>,
733    ordering: Option<&str>,
734    owner: Option<Vec<String>>,
735    owner__n: Option<Vec<String>>,
736    owner_id: Option<Vec<i32>>,
737    owner_id__n: Option<Vec<i32>>,
738    permission_id: Option<Vec<i32>>,
739    permission_id__n: Option<Vec<i32>>,
740    q: Option<&str>,
741    start: Option<i32>,
742    user_id: Option<Vec<i32>>,
743    user_id__n: Option<Vec<i32>>,
744) -> Result<crate::models::PaginatedGroupList, Error<UsersGroupsListError>> {
745    let local_var_configuration = configuration;
746
747    let local_var_client = &local_var_configuration.client;
748
749    let local_var_uri_str = format!("{}/api/users/groups/", local_var_configuration.base_path);
750    let mut local_var_req_builder =
751        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
752
753    if let Some(ref local_var_str) = description {
754        local_var_req_builder = match "multi" {
755            "multi" => local_var_req_builder.query(
756                &local_var_str
757                    .into_iter()
758                    .map(|p| ("description".to_owned(), p.to_string()))
759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
760            ),
761            _ => local_var_req_builder.query(&[(
762                "description",
763                &local_var_str
764                    .into_iter()
765                    .map(|p| p.to_string())
766                    .collect::<Vec<String>>()
767                    .join(",")
768                    .to_string(),
769            )]),
770        };
771    }
772    if let Some(ref local_var_str) = description__empty {
773        local_var_req_builder =
774            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
775    }
776    if let Some(ref local_var_str) = description__ic {
777        local_var_req_builder = match "multi" {
778            "multi" => local_var_req_builder.query(
779                &local_var_str
780                    .into_iter()
781                    .map(|p| ("description__ic".to_owned(), p.to_string()))
782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
783            ),
784            _ => local_var_req_builder.query(&[(
785                "description__ic",
786                &local_var_str
787                    .into_iter()
788                    .map(|p| p.to_string())
789                    .collect::<Vec<String>>()
790                    .join(",")
791                    .to_string(),
792            )]),
793        };
794    }
795    if let Some(ref local_var_str) = description__ie {
796        local_var_req_builder = match "multi" {
797            "multi" => local_var_req_builder.query(
798                &local_var_str
799                    .into_iter()
800                    .map(|p| ("description__ie".to_owned(), p.to_string()))
801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
802            ),
803            _ => local_var_req_builder.query(&[(
804                "description__ie",
805                &local_var_str
806                    .into_iter()
807                    .map(|p| p.to_string())
808                    .collect::<Vec<String>>()
809                    .join(",")
810                    .to_string(),
811            )]),
812        };
813    }
814    if let Some(ref local_var_str) = description__iew {
815        local_var_req_builder = match "multi" {
816            "multi" => local_var_req_builder.query(
817                &local_var_str
818                    .into_iter()
819                    .map(|p| ("description__iew".to_owned(), p.to_string()))
820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
821            ),
822            _ => local_var_req_builder.query(&[(
823                "description__iew",
824                &local_var_str
825                    .into_iter()
826                    .map(|p| p.to_string())
827                    .collect::<Vec<String>>()
828                    .join(",")
829                    .to_string(),
830            )]),
831        };
832    }
833    if let Some(ref local_var_str) = description__iregex {
834        local_var_req_builder = match "multi" {
835            "multi" => local_var_req_builder.query(
836                &local_var_str
837                    .into_iter()
838                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
840            ),
841            _ => local_var_req_builder.query(&[(
842                "description__iregex",
843                &local_var_str
844                    .into_iter()
845                    .map(|p| p.to_string())
846                    .collect::<Vec<String>>()
847                    .join(",")
848                    .to_string(),
849            )]),
850        };
851    }
852    if let Some(ref local_var_str) = description__isw {
853        local_var_req_builder = match "multi" {
854            "multi" => local_var_req_builder.query(
855                &local_var_str
856                    .into_iter()
857                    .map(|p| ("description__isw".to_owned(), p.to_string()))
858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
859            ),
860            _ => local_var_req_builder.query(&[(
861                "description__isw",
862                &local_var_str
863                    .into_iter()
864                    .map(|p| p.to_string())
865                    .collect::<Vec<String>>()
866                    .join(",")
867                    .to_string(),
868            )]),
869        };
870    }
871    if let Some(ref local_var_str) = description__n {
872        local_var_req_builder = match "multi" {
873            "multi" => local_var_req_builder.query(
874                &local_var_str
875                    .into_iter()
876                    .map(|p| ("description__n".to_owned(), p.to_string()))
877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
878            ),
879            _ => local_var_req_builder.query(&[(
880                "description__n",
881                &local_var_str
882                    .into_iter()
883                    .map(|p| p.to_string())
884                    .collect::<Vec<String>>()
885                    .join(",")
886                    .to_string(),
887            )]),
888        };
889    }
890    if let Some(ref local_var_str) = description__nic {
891        local_var_req_builder = match "multi" {
892            "multi" => local_var_req_builder.query(
893                &local_var_str
894                    .into_iter()
895                    .map(|p| ("description__nic".to_owned(), p.to_string()))
896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
897            ),
898            _ => local_var_req_builder.query(&[(
899                "description__nic",
900                &local_var_str
901                    .into_iter()
902                    .map(|p| p.to_string())
903                    .collect::<Vec<String>>()
904                    .join(",")
905                    .to_string(),
906            )]),
907        };
908    }
909    if let Some(ref local_var_str) = description__nie {
910        local_var_req_builder = match "multi" {
911            "multi" => local_var_req_builder.query(
912                &local_var_str
913                    .into_iter()
914                    .map(|p| ("description__nie".to_owned(), p.to_string()))
915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
916            ),
917            _ => local_var_req_builder.query(&[(
918                "description__nie",
919                &local_var_str
920                    .into_iter()
921                    .map(|p| p.to_string())
922                    .collect::<Vec<String>>()
923                    .join(",")
924                    .to_string(),
925            )]),
926        };
927    }
928    if let Some(ref local_var_str) = description__niew {
929        local_var_req_builder = match "multi" {
930            "multi" => local_var_req_builder.query(
931                &local_var_str
932                    .into_iter()
933                    .map(|p| ("description__niew".to_owned(), p.to_string()))
934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
935            ),
936            _ => local_var_req_builder.query(&[(
937                "description__niew",
938                &local_var_str
939                    .into_iter()
940                    .map(|p| p.to_string())
941                    .collect::<Vec<String>>()
942                    .join(",")
943                    .to_string(),
944            )]),
945        };
946    }
947    if let Some(ref local_var_str) = description__nisw {
948        local_var_req_builder = match "multi" {
949            "multi" => local_var_req_builder.query(
950                &local_var_str
951                    .into_iter()
952                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
954            ),
955            _ => local_var_req_builder.query(&[(
956                "description__nisw",
957                &local_var_str
958                    .into_iter()
959                    .map(|p| p.to_string())
960                    .collect::<Vec<String>>()
961                    .join(",")
962                    .to_string(),
963            )]),
964        };
965    }
966    if let Some(ref local_var_str) = description__regex {
967        local_var_req_builder = match "multi" {
968            "multi" => local_var_req_builder.query(
969                &local_var_str
970                    .into_iter()
971                    .map(|p| ("description__regex".to_owned(), p.to_string()))
972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
973            ),
974            _ => local_var_req_builder.query(&[(
975                "description__regex",
976                &local_var_str
977                    .into_iter()
978                    .map(|p| p.to_string())
979                    .collect::<Vec<String>>()
980                    .join(",")
981                    .to_string(),
982            )]),
983        };
984    }
985    if let Some(ref local_var_str) = id {
986        local_var_req_builder = match "multi" {
987            "multi" => local_var_req_builder.query(
988                &local_var_str
989                    .into_iter()
990                    .map(|p| ("id".to_owned(), p.to_string()))
991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
992            ),
993            _ => local_var_req_builder.query(&[(
994                "id",
995                &local_var_str
996                    .into_iter()
997                    .map(|p| p.to_string())
998                    .collect::<Vec<String>>()
999                    .join(",")
1000                    .to_string(),
1001            )]),
1002        };
1003    }
1004    if let Some(ref local_var_str) = id__empty {
1005        local_var_req_builder =
1006            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1007    }
1008    if let Some(ref local_var_str) = id__gt {
1009        local_var_req_builder = match "multi" {
1010            "multi" => local_var_req_builder.query(
1011                &local_var_str
1012                    .into_iter()
1013                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1014                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1015            ),
1016            _ => local_var_req_builder.query(&[(
1017                "id__gt",
1018                &local_var_str
1019                    .into_iter()
1020                    .map(|p| p.to_string())
1021                    .collect::<Vec<String>>()
1022                    .join(",")
1023                    .to_string(),
1024            )]),
1025        };
1026    }
1027    if let Some(ref local_var_str) = id__gte {
1028        local_var_req_builder = match "multi" {
1029            "multi" => local_var_req_builder.query(
1030                &local_var_str
1031                    .into_iter()
1032                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1033                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1034            ),
1035            _ => local_var_req_builder.query(&[(
1036                "id__gte",
1037                &local_var_str
1038                    .into_iter()
1039                    .map(|p| p.to_string())
1040                    .collect::<Vec<String>>()
1041                    .join(",")
1042                    .to_string(),
1043            )]),
1044        };
1045    }
1046    if let Some(ref local_var_str) = id__lt {
1047        local_var_req_builder = match "multi" {
1048            "multi" => local_var_req_builder.query(
1049                &local_var_str
1050                    .into_iter()
1051                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1052                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1053            ),
1054            _ => local_var_req_builder.query(&[(
1055                "id__lt",
1056                &local_var_str
1057                    .into_iter()
1058                    .map(|p| p.to_string())
1059                    .collect::<Vec<String>>()
1060                    .join(",")
1061                    .to_string(),
1062            )]),
1063        };
1064    }
1065    if let Some(ref local_var_str) = id__lte {
1066        local_var_req_builder = match "multi" {
1067            "multi" => local_var_req_builder.query(
1068                &local_var_str
1069                    .into_iter()
1070                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1072            ),
1073            _ => local_var_req_builder.query(&[(
1074                "id__lte",
1075                &local_var_str
1076                    .into_iter()
1077                    .map(|p| p.to_string())
1078                    .collect::<Vec<String>>()
1079                    .join(",")
1080                    .to_string(),
1081            )]),
1082        };
1083    }
1084    if let Some(ref local_var_str) = id__n {
1085        local_var_req_builder = match "multi" {
1086            "multi" => local_var_req_builder.query(
1087                &local_var_str
1088                    .into_iter()
1089                    .map(|p| ("id__n".to_owned(), p.to_string()))
1090                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1091            ),
1092            _ => local_var_req_builder.query(&[(
1093                "id__n",
1094                &local_var_str
1095                    .into_iter()
1096                    .map(|p| p.to_string())
1097                    .collect::<Vec<String>>()
1098                    .join(",")
1099                    .to_string(),
1100            )]),
1101        };
1102    }
1103    if let Some(ref local_var_str) = limit {
1104        local_var_req_builder =
1105            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1106    }
1107    if let Some(ref local_var_str) = name {
1108        local_var_req_builder = match "multi" {
1109            "multi" => local_var_req_builder.query(
1110                &local_var_str
1111                    .into_iter()
1112                    .map(|p| ("name".to_owned(), p.to_string()))
1113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1114            ),
1115            _ => local_var_req_builder.query(&[(
1116                "name",
1117                &local_var_str
1118                    .into_iter()
1119                    .map(|p| p.to_string())
1120                    .collect::<Vec<String>>()
1121                    .join(",")
1122                    .to_string(),
1123            )]),
1124        };
1125    }
1126    if let Some(ref local_var_str) = name__empty {
1127        local_var_req_builder =
1128            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1129    }
1130    if let Some(ref local_var_str) = name__ic {
1131        local_var_req_builder = match "multi" {
1132            "multi" => local_var_req_builder.query(
1133                &local_var_str
1134                    .into_iter()
1135                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1137            ),
1138            _ => local_var_req_builder.query(&[(
1139                "name__ic",
1140                &local_var_str
1141                    .into_iter()
1142                    .map(|p| p.to_string())
1143                    .collect::<Vec<String>>()
1144                    .join(",")
1145                    .to_string(),
1146            )]),
1147        };
1148    }
1149    if let Some(ref local_var_str) = name__ie {
1150        local_var_req_builder = match "multi" {
1151            "multi" => local_var_req_builder.query(
1152                &local_var_str
1153                    .into_iter()
1154                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1156            ),
1157            _ => local_var_req_builder.query(&[(
1158                "name__ie",
1159                &local_var_str
1160                    .into_iter()
1161                    .map(|p| p.to_string())
1162                    .collect::<Vec<String>>()
1163                    .join(",")
1164                    .to_string(),
1165            )]),
1166        };
1167    }
1168    if let Some(ref local_var_str) = name__iew {
1169        local_var_req_builder = match "multi" {
1170            "multi" => local_var_req_builder.query(
1171                &local_var_str
1172                    .into_iter()
1173                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1175            ),
1176            _ => local_var_req_builder.query(&[(
1177                "name__iew",
1178                &local_var_str
1179                    .into_iter()
1180                    .map(|p| p.to_string())
1181                    .collect::<Vec<String>>()
1182                    .join(",")
1183                    .to_string(),
1184            )]),
1185        };
1186    }
1187    if let Some(ref local_var_str) = name__iregex {
1188        local_var_req_builder = match "multi" {
1189            "multi" => local_var_req_builder.query(
1190                &local_var_str
1191                    .into_iter()
1192                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
1193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1194            ),
1195            _ => local_var_req_builder.query(&[(
1196                "name__iregex",
1197                &local_var_str
1198                    .into_iter()
1199                    .map(|p| p.to_string())
1200                    .collect::<Vec<String>>()
1201                    .join(",")
1202                    .to_string(),
1203            )]),
1204        };
1205    }
1206    if let Some(ref local_var_str) = name__isw {
1207        local_var_req_builder = match "multi" {
1208            "multi" => local_var_req_builder.query(
1209                &local_var_str
1210                    .into_iter()
1211                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1213            ),
1214            _ => local_var_req_builder.query(&[(
1215                "name__isw",
1216                &local_var_str
1217                    .into_iter()
1218                    .map(|p| p.to_string())
1219                    .collect::<Vec<String>>()
1220                    .join(",")
1221                    .to_string(),
1222            )]),
1223        };
1224    }
1225    if let Some(ref local_var_str) = name__n {
1226        local_var_req_builder = match "multi" {
1227            "multi" => local_var_req_builder.query(
1228                &local_var_str
1229                    .into_iter()
1230                    .map(|p| ("name__n".to_owned(), p.to_string()))
1231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1232            ),
1233            _ => local_var_req_builder.query(&[(
1234                "name__n",
1235                &local_var_str
1236                    .into_iter()
1237                    .map(|p| p.to_string())
1238                    .collect::<Vec<String>>()
1239                    .join(",")
1240                    .to_string(),
1241            )]),
1242        };
1243    }
1244    if let Some(ref local_var_str) = name__nic {
1245        local_var_req_builder = match "multi" {
1246            "multi" => local_var_req_builder.query(
1247                &local_var_str
1248                    .into_iter()
1249                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1250                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1251            ),
1252            _ => local_var_req_builder.query(&[(
1253                "name__nic",
1254                &local_var_str
1255                    .into_iter()
1256                    .map(|p| p.to_string())
1257                    .collect::<Vec<String>>()
1258                    .join(",")
1259                    .to_string(),
1260            )]),
1261        };
1262    }
1263    if let Some(ref local_var_str) = name__nie {
1264        local_var_req_builder = match "multi" {
1265            "multi" => local_var_req_builder.query(
1266                &local_var_str
1267                    .into_iter()
1268                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1270            ),
1271            _ => local_var_req_builder.query(&[(
1272                "name__nie",
1273                &local_var_str
1274                    .into_iter()
1275                    .map(|p| p.to_string())
1276                    .collect::<Vec<String>>()
1277                    .join(",")
1278                    .to_string(),
1279            )]),
1280        };
1281    }
1282    if let Some(ref local_var_str) = name__niew {
1283        local_var_req_builder = match "multi" {
1284            "multi" => local_var_req_builder.query(
1285                &local_var_str
1286                    .into_iter()
1287                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1289            ),
1290            _ => local_var_req_builder.query(&[(
1291                "name__niew",
1292                &local_var_str
1293                    .into_iter()
1294                    .map(|p| p.to_string())
1295                    .collect::<Vec<String>>()
1296                    .join(",")
1297                    .to_string(),
1298            )]),
1299        };
1300    }
1301    if let Some(ref local_var_str) = name__nisw {
1302        local_var_req_builder = match "multi" {
1303            "multi" => local_var_req_builder.query(
1304                &local_var_str
1305                    .into_iter()
1306                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1308            ),
1309            _ => local_var_req_builder.query(&[(
1310                "name__nisw",
1311                &local_var_str
1312                    .into_iter()
1313                    .map(|p| p.to_string())
1314                    .collect::<Vec<String>>()
1315                    .join(",")
1316                    .to_string(),
1317            )]),
1318        };
1319    }
1320    if let Some(ref local_var_str) = name__regex {
1321        local_var_req_builder = match "multi" {
1322            "multi" => local_var_req_builder.query(
1323                &local_var_str
1324                    .into_iter()
1325                    .map(|p| ("name__regex".to_owned(), p.to_string()))
1326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1327            ),
1328            _ => local_var_req_builder.query(&[(
1329                "name__regex",
1330                &local_var_str
1331                    .into_iter()
1332                    .map(|p| p.to_string())
1333                    .collect::<Vec<String>>()
1334                    .join(",")
1335                    .to_string(),
1336            )]),
1337        };
1338    }
1339    if let Some(ref local_var_str) = notification_group_id {
1340        local_var_req_builder = match "multi" {
1341            "multi" => local_var_req_builder.query(
1342                &local_var_str
1343                    .into_iter()
1344                    .map(|p| ("notification_group_id".to_owned(), p.to_string()))
1345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1346            ),
1347            _ => local_var_req_builder.query(&[(
1348                "notification_group_id",
1349                &local_var_str
1350                    .into_iter()
1351                    .map(|p| p.to_string())
1352                    .collect::<Vec<String>>()
1353                    .join(",")
1354                    .to_string(),
1355            )]),
1356        };
1357    }
1358    if let Some(ref local_var_str) = notification_group_id__n {
1359        local_var_req_builder = match "multi" {
1360            "multi" => local_var_req_builder.query(
1361                &local_var_str
1362                    .into_iter()
1363                    .map(|p| ("notification_group_id__n".to_owned(), p.to_string()))
1364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1365            ),
1366            _ => local_var_req_builder.query(&[(
1367                "notification_group_id__n",
1368                &local_var_str
1369                    .into_iter()
1370                    .map(|p| p.to_string())
1371                    .collect::<Vec<String>>()
1372                    .join(",")
1373                    .to_string(),
1374            )]),
1375        };
1376    }
1377    if let Some(ref local_var_str) = offset {
1378        local_var_req_builder =
1379            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1380    }
1381    if let Some(ref local_var_str) = ordering {
1382        local_var_req_builder =
1383            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1384    }
1385    if let Some(ref local_var_str) = owner {
1386        local_var_req_builder = match "multi" {
1387            "multi" => local_var_req_builder.query(
1388                &local_var_str
1389                    .into_iter()
1390                    .map(|p| ("owner".to_owned(), p.to_string()))
1391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1392            ),
1393            _ => local_var_req_builder.query(&[(
1394                "owner",
1395                &local_var_str
1396                    .into_iter()
1397                    .map(|p| p.to_string())
1398                    .collect::<Vec<String>>()
1399                    .join(",")
1400                    .to_string(),
1401            )]),
1402        };
1403    }
1404    if let Some(ref local_var_str) = owner__n {
1405        local_var_req_builder = match "multi" {
1406            "multi" => local_var_req_builder.query(
1407                &local_var_str
1408                    .into_iter()
1409                    .map(|p| ("owner__n".to_owned(), p.to_string()))
1410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1411            ),
1412            _ => local_var_req_builder.query(&[(
1413                "owner__n",
1414                &local_var_str
1415                    .into_iter()
1416                    .map(|p| p.to_string())
1417                    .collect::<Vec<String>>()
1418                    .join(",")
1419                    .to_string(),
1420            )]),
1421        };
1422    }
1423    if let Some(ref local_var_str) = owner_id {
1424        local_var_req_builder = match "multi" {
1425            "multi" => local_var_req_builder.query(
1426                &local_var_str
1427                    .into_iter()
1428                    .map(|p| ("owner_id".to_owned(), p.to_string()))
1429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1430            ),
1431            _ => local_var_req_builder.query(&[(
1432                "owner_id",
1433                &local_var_str
1434                    .into_iter()
1435                    .map(|p| p.to_string())
1436                    .collect::<Vec<String>>()
1437                    .join(",")
1438                    .to_string(),
1439            )]),
1440        };
1441    }
1442    if let Some(ref local_var_str) = owner_id__n {
1443        local_var_req_builder = match "multi" {
1444            "multi" => local_var_req_builder.query(
1445                &local_var_str
1446                    .into_iter()
1447                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
1448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1449            ),
1450            _ => local_var_req_builder.query(&[(
1451                "owner_id__n",
1452                &local_var_str
1453                    .into_iter()
1454                    .map(|p| p.to_string())
1455                    .collect::<Vec<String>>()
1456                    .join(",")
1457                    .to_string(),
1458            )]),
1459        };
1460    }
1461    if let Some(ref local_var_str) = permission_id {
1462        local_var_req_builder = match "multi" {
1463            "multi" => local_var_req_builder.query(
1464                &local_var_str
1465                    .into_iter()
1466                    .map(|p| ("permission_id".to_owned(), p.to_string()))
1467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1468            ),
1469            _ => local_var_req_builder.query(&[(
1470                "permission_id",
1471                &local_var_str
1472                    .into_iter()
1473                    .map(|p| p.to_string())
1474                    .collect::<Vec<String>>()
1475                    .join(",")
1476                    .to_string(),
1477            )]),
1478        };
1479    }
1480    if let Some(ref local_var_str) = permission_id__n {
1481        local_var_req_builder = match "multi" {
1482            "multi" => local_var_req_builder.query(
1483                &local_var_str
1484                    .into_iter()
1485                    .map(|p| ("permission_id__n".to_owned(), p.to_string()))
1486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1487            ),
1488            _ => local_var_req_builder.query(&[(
1489                "permission_id__n",
1490                &local_var_str
1491                    .into_iter()
1492                    .map(|p| p.to_string())
1493                    .collect::<Vec<String>>()
1494                    .join(",")
1495                    .to_string(),
1496            )]),
1497        };
1498    }
1499    if let Some(ref local_var_str) = q {
1500        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1501    }
1502    if let Some(ref local_var_str) = start {
1503        local_var_req_builder =
1504            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
1505    }
1506    if let Some(ref local_var_str) = user_id {
1507        local_var_req_builder = match "multi" {
1508            "multi" => local_var_req_builder.query(
1509                &local_var_str
1510                    .into_iter()
1511                    .map(|p| ("user_id".to_owned(), p.to_string()))
1512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1513            ),
1514            _ => local_var_req_builder.query(&[(
1515                "user_id",
1516                &local_var_str
1517                    .into_iter()
1518                    .map(|p| p.to_string())
1519                    .collect::<Vec<String>>()
1520                    .join(",")
1521                    .to_string(),
1522            )]),
1523        };
1524    }
1525    if let Some(ref local_var_str) = user_id__n {
1526        local_var_req_builder = match "multi" {
1527            "multi" => local_var_req_builder.query(
1528                &local_var_str
1529                    .into_iter()
1530                    .map(|p| ("user_id__n".to_owned(), p.to_string()))
1531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1532            ),
1533            _ => local_var_req_builder.query(&[(
1534                "user_id__n",
1535                &local_var_str
1536                    .into_iter()
1537                    .map(|p| p.to_string())
1538                    .collect::<Vec<String>>()
1539                    .join(",")
1540                    .to_string(),
1541            )]),
1542        };
1543    }
1544    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1545        local_var_req_builder =
1546            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1547    }
1548    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1549        let local_var_key = local_var_apikey.key.clone();
1550        let local_var_value = match local_var_apikey.prefix {
1551            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1552            None => local_var_key,
1553        };
1554        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1555    };
1556
1557    let local_var_req = local_var_req_builder.build()?;
1558    let local_var_resp = local_var_client.execute(local_var_req).await?;
1559
1560    let local_var_status = local_var_resp.status();
1561    let local_var_content = local_var_resp.text().await?;
1562
1563    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1564        serde_json::from_str(&local_var_content).map_err(Error::from)
1565    } else {
1566        let local_var_entity: Option<UsersGroupsListError> =
1567            serde_json::from_str(&local_var_content).ok();
1568        let local_var_error = ResponseContent {
1569            status: local_var_status,
1570            content: local_var_content,
1571            entity: local_var_entity,
1572        };
1573        Err(Error::ResponseError(local_var_error))
1574    }
1575}
1576
1577/// Patch a group object.
1578pub async fn users_groups_partial_update(
1579    configuration: &configuration::Configuration,
1580    id: i32,
1581    patched_group_request: Option<crate::models::PatchedGroupRequest>,
1582) -> Result<crate::models::Group, Error<UsersGroupsPartialUpdateError>> {
1583    let local_var_configuration = configuration;
1584
1585    let local_var_client = &local_var_configuration.client;
1586
1587    let local_var_uri_str = format!(
1588        "{}/api/users/groups/{id}/",
1589        local_var_configuration.base_path,
1590        id = id
1591    );
1592    let mut local_var_req_builder =
1593        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1594
1595    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1596        local_var_req_builder =
1597            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1598    }
1599    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1600        let local_var_key = local_var_apikey.key.clone();
1601        let local_var_value = match local_var_apikey.prefix {
1602            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1603            None => local_var_key,
1604        };
1605        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1606    };
1607    local_var_req_builder = local_var_req_builder.json(&patched_group_request);
1608
1609    let local_var_req = local_var_req_builder.build()?;
1610    let local_var_resp = local_var_client.execute(local_var_req).await?;
1611
1612    let local_var_status = local_var_resp.status();
1613    let local_var_content = local_var_resp.text().await?;
1614
1615    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1616        serde_json::from_str(&local_var_content).map_err(Error::from)
1617    } else {
1618        let local_var_entity: Option<UsersGroupsPartialUpdateError> =
1619            serde_json::from_str(&local_var_content).ok();
1620        let local_var_error = ResponseContent {
1621            status: local_var_status,
1622            content: local_var_content,
1623            entity: local_var_entity,
1624        };
1625        Err(Error::ResponseError(local_var_error))
1626    }
1627}
1628
1629/// Get a group object.
1630pub async fn users_groups_retrieve(
1631    configuration: &configuration::Configuration,
1632    id: i32,
1633) -> Result<crate::models::Group, Error<UsersGroupsRetrieveError>> {
1634    let local_var_configuration = configuration;
1635
1636    let local_var_client = &local_var_configuration.client;
1637
1638    let local_var_uri_str = format!(
1639        "{}/api/users/groups/{id}/",
1640        local_var_configuration.base_path,
1641        id = id
1642    );
1643    let mut local_var_req_builder =
1644        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1645
1646    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1647        local_var_req_builder =
1648            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1649    }
1650    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1651        let local_var_key = local_var_apikey.key.clone();
1652        let local_var_value = match local_var_apikey.prefix {
1653            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1654            None => local_var_key,
1655        };
1656        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1657    };
1658
1659    let local_var_req = local_var_req_builder.build()?;
1660    let local_var_resp = local_var_client.execute(local_var_req).await?;
1661
1662    let local_var_status = local_var_resp.status();
1663    let local_var_content = local_var_resp.text().await?;
1664
1665    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1666        serde_json::from_str(&local_var_content).map_err(Error::from)
1667    } else {
1668        let local_var_entity: Option<UsersGroupsRetrieveError> =
1669            serde_json::from_str(&local_var_content).ok();
1670        let local_var_error = ResponseContent {
1671            status: local_var_status,
1672            content: local_var_content,
1673            entity: local_var_entity,
1674        };
1675        Err(Error::ResponseError(local_var_error))
1676    }
1677}
1678
1679/// Put a group object.
1680pub async fn users_groups_update(
1681    configuration: &configuration::Configuration,
1682    id: i32,
1683    group_request: crate::models::GroupRequest,
1684) -> Result<crate::models::Group, Error<UsersGroupsUpdateError>> {
1685    let local_var_configuration = configuration;
1686
1687    let local_var_client = &local_var_configuration.client;
1688
1689    let local_var_uri_str = format!(
1690        "{}/api/users/groups/{id}/",
1691        local_var_configuration.base_path,
1692        id = id
1693    );
1694    let mut local_var_req_builder =
1695        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1696
1697    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1698        local_var_req_builder =
1699            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1700    }
1701    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1702        let local_var_key = local_var_apikey.key.clone();
1703        let local_var_value = match local_var_apikey.prefix {
1704            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1705            None => local_var_key,
1706        };
1707        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1708    };
1709    local_var_req_builder = local_var_req_builder.json(&group_request);
1710
1711    let local_var_req = local_var_req_builder.build()?;
1712    let local_var_resp = local_var_client.execute(local_var_req).await?;
1713
1714    let local_var_status = local_var_resp.status();
1715    let local_var_content = local_var_resp.text().await?;
1716
1717    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1718        serde_json::from_str(&local_var_content).map_err(Error::from)
1719    } else {
1720        let local_var_entity: Option<UsersGroupsUpdateError> =
1721            serde_json::from_str(&local_var_content).ok();
1722        let local_var_error = ResponseContent {
1723            status: local_var_status,
1724            content: local_var_content,
1725            entity: local_var_entity,
1726        };
1727        Err(Error::ResponseError(local_var_error))
1728    }
1729}
1730
1731/// Delete a list of owner group objects.
1732pub async fn users_owner_groups_bulk_destroy(
1733    configuration: &configuration::Configuration,
1734    owner_group_request: Vec<crate::models::OwnerGroupRequest>,
1735) -> Result<(), Error<UsersOwnerGroupsBulkDestroyError>> {
1736    let local_var_configuration = configuration;
1737
1738    let local_var_client = &local_var_configuration.client;
1739
1740    let local_var_uri_str = format!(
1741        "{}/api/users/owner-groups/",
1742        local_var_configuration.base_path
1743    );
1744    let mut local_var_req_builder =
1745        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1746
1747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1748        local_var_req_builder =
1749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1750    }
1751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1752        let local_var_key = local_var_apikey.key.clone();
1753        let local_var_value = match local_var_apikey.prefix {
1754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1755            None => local_var_key,
1756        };
1757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1758    };
1759    local_var_req_builder = local_var_req_builder.json(&owner_group_request);
1760
1761    let local_var_req = local_var_req_builder.build()?;
1762    let local_var_resp = local_var_client.execute(local_var_req).await?;
1763
1764    let local_var_status = local_var_resp.status();
1765    let local_var_content = local_var_resp.text().await?;
1766
1767    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1768        Ok(())
1769    } else {
1770        let local_var_entity: Option<UsersOwnerGroupsBulkDestroyError> =
1771            serde_json::from_str(&local_var_content).ok();
1772        let local_var_error = ResponseContent {
1773            status: local_var_status,
1774            content: local_var_content,
1775            entity: local_var_entity,
1776        };
1777        Err(Error::ResponseError(local_var_error))
1778    }
1779}
1780
1781/// Patch a list of owner group objects.
1782pub async fn users_owner_groups_bulk_partial_update(
1783    configuration: &configuration::Configuration,
1784    owner_group_request: Vec<crate::models::OwnerGroupRequest>,
1785) -> Result<Vec<crate::models::OwnerGroup>, Error<UsersOwnerGroupsBulkPartialUpdateError>> {
1786    let local_var_configuration = configuration;
1787
1788    let local_var_client = &local_var_configuration.client;
1789
1790    let local_var_uri_str = format!(
1791        "{}/api/users/owner-groups/",
1792        local_var_configuration.base_path
1793    );
1794    let mut local_var_req_builder =
1795        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1796
1797    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1798        local_var_req_builder =
1799            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1800    }
1801    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1802        let local_var_key = local_var_apikey.key.clone();
1803        let local_var_value = match local_var_apikey.prefix {
1804            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1805            None => local_var_key,
1806        };
1807        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1808    };
1809    local_var_req_builder = local_var_req_builder.json(&owner_group_request);
1810
1811    let local_var_req = local_var_req_builder.build()?;
1812    let local_var_resp = local_var_client.execute(local_var_req).await?;
1813
1814    let local_var_status = local_var_resp.status();
1815    let local_var_content = local_var_resp.text().await?;
1816
1817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1818        serde_json::from_str(&local_var_content).map_err(Error::from)
1819    } else {
1820        let local_var_entity: Option<UsersOwnerGroupsBulkPartialUpdateError> =
1821            serde_json::from_str(&local_var_content).ok();
1822        let local_var_error = ResponseContent {
1823            status: local_var_status,
1824            content: local_var_content,
1825            entity: local_var_entity,
1826        };
1827        Err(Error::ResponseError(local_var_error))
1828    }
1829}
1830
1831/// Put a list of owner group objects.
1832pub async fn users_owner_groups_bulk_update(
1833    configuration: &configuration::Configuration,
1834    owner_group_request: Vec<crate::models::OwnerGroupRequest>,
1835) -> Result<Vec<crate::models::OwnerGroup>, Error<UsersOwnerGroupsBulkUpdateError>> {
1836    let local_var_configuration = configuration;
1837
1838    let local_var_client = &local_var_configuration.client;
1839
1840    let local_var_uri_str = format!(
1841        "{}/api/users/owner-groups/",
1842        local_var_configuration.base_path
1843    );
1844    let mut local_var_req_builder =
1845        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1846
1847    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1848        local_var_req_builder =
1849            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1850    }
1851    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1852        let local_var_key = local_var_apikey.key.clone();
1853        let local_var_value = match local_var_apikey.prefix {
1854            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1855            None => local_var_key,
1856        };
1857        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1858    };
1859    local_var_req_builder = local_var_req_builder.json(&owner_group_request);
1860
1861    let local_var_req = local_var_req_builder.build()?;
1862    let local_var_resp = local_var_client.execute(local_var_req).await?;
1863
1864    let local_var_status = local_var_resp.status();
1865    let local_var_content = local_var_resp.text().await?;
1866
1867    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1868        serde_json::from_str(&local_var_content).map_err(Error::from)
1869    } else {
1870        let local_var_entity: Option<UsersOwnerGroupsBulkUpdateError> =
1871            serde_json::from_str(&local_var_content).ok();
1872        let local_var_error = ResponseContent {
1873            status: local_var_status,
1874            content: local_var_content,
1875            entity: local_var_entity,
1876        };
1877        Err(Error::ResponseError(local_var_error))
1878    }
1879}
1880
1881/// Post a list of owner group objects.
1882pub async fn users_owner_groups_create(
1883    configuration: &configuration::Configuration,
1884    users_owner_groups_create_request: crate::models::UsersOwnerGroupsCreateRequest,
1885) -> Result<crate::models::OwnerGroup, Error<UsersOwnerGroupsCreateError>> {
1886    let local_var_configuration = configuration;
1887
1888    let local_var_client = &local_var_configuration.client;
1889
1890    let local_var_uri_str = format!(
1891        "{}/api/users/owner-groups/",
1892        local_var_configuration.base_path
1893    );
1894    let mut local_var_req_builder =
1895        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1896
1897    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1898        local_var_req_builder =
1899            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1900    }
1901    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1902        let local_var_key = local_var_apikey.key.clone();
1903        let local_var_value = match local_var_apikey.prefix {
1904            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1905            None => local_var_key,
1906        };
1907        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1908    };
1909    local_var_req_builder = local_var_req_builder.json(&users_owner_groups_create_request);
1910
1911    let local_var_req = local_var_req_builder.build()?;
1912    let local_var_resp = local_var_client.execute(local_var_req).await?;
1913
1914    let local_var_status = local_var_resp.status();
1915    let local_var_content = local_var_resp.text().await?;
1916
1917    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1918        serde_json::from_str(&local_var_content).map_err(Error::from)
1919    } else {
1920        let local_var_entity: Option<UsersOwnerGroupsCreateError> =
1921            serde_json::from_str(&local_var_content).ok();
1922        let local_var_error = ResponseContent {
1923            status: local_var_status,
1924            content: local_var_content,
1925            entity: local_var_entity,
1926        };
1927        Err(Error::ResponseError(local_var_error))
1928    }
1929}
1930
1931/// Delete a owner group object.
1932pub async fn users_owner_groups_destroy(
1933    configuration: &configuration::Configuration,
1934    id: i32,
1935) -> Result<(), Error<UsersOwnerGroupsDestroyError>> {
1936    let local_var_configuration = configuration;
1937
1938    let local_var_client = &local_var_configuration.client;
1939
1940    let local_var_uri_str = format!(
1941        "{}/api/users/owner-groups/{id}/",
1942        local_var_configuration.base_path,
1943        id = id
1944    );
1945    let mut local_var_req_builder =
1946        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1947
1948    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1949        local_var_req_builder =
1950            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1951    }
1952    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1953        let local_var_key = local_var_apikey.key.clone();
1954        let local_var_value = match local_var_apikey.prefix {
1955            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1956            None => local_var_key,
1957        };
1958        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1959    };
1960
1961    let local_var_req = local_var_req_builder.build()?;
1962    let local_var_resp = local_var_client.execute(local_var_req).await?;
1963
1964    let local_var_status = local_var_resp.status();
1965    let local_var_content = local_var_resp.text().await?;
1966
1967    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1968        Ok(())
1969    } else {
1970        let local_var_entity: Option<UsersOwnerGroupsDestroyError> =
1971            serde_json::from_str(&local_var_content).ok();
1972        let local_var_error = ResponseContent {
1973            status: local_var_status,
1974            content: local_var_content,
1975            entity: local_var_entity,
1976        };
1977        Err(Error::ResponseError(local_var_error))
1978    }
1979}
1980
1981/// Get a list of owner group objects.
1982pub async fn users_owner_groups_list(
1983    configuration: &configuration::Configuration,
1984    description: Option<Vec<String>>,
1985    description__empty: Option<bool>,
1986    description__ic: Option<Vec<String>>,
1987    description__ie: Option<Vec<String>>,
1988    description__iew: Option<Vec<String>>,
1989    description__iregex: Option<Vec<String>>,
1990    description__isw: Option<Vec<String>>,
1991    description__n: Option<Vec<String>>,
1992    description__nic: Option<Vec<String>>,
1993    description__nie: Option<Vec<String>>,
1994    description__niew: Option<Vec<String>>,
1995    description__nisw: Option<Vec<String>>,
1996    description__regex: Option<Vec<String>>,
1997    id: Option<Vec<i32>>,
1998    id__empty: Option<bool>,
1999    id__gt: Option<Vec<i32>>,
2000    id__gte: Option<Vec<i32>>,
2001    id__lt: Option<Vec<i32>>,
2002    id__lte: Option<Vec<i32>>,
2003    id__n: Option<Vec<i32>>,
2004    limit: Option<i32>,
2005    name: Option<Vec<String>>,
2006    name__empty: Option<bool>,
2007    name__ic: Option<Vec<String>>,
2008    name__ie: Option<Vec<String>>,
2009    name__iew: Option<Vec<String>>,
2010    name__iregex: Option<Vec<String>>,
2011    name__isw: Option<Vec<String>>,
2012    name__n: Option<Vec<String>>,
2013    name__nic: Option<Vec<String>>,
2014    name__nie: Option<Vec<String>>,
2015    name__niew: Option<Vec<String>>,
2016    name__nisw: Option<Vec<String>>,
2017    name__regex: Option<Vec<String>>,
2018    offset: Option<i32>,
2019    ordering: Option<&str>,
2020    q: Option<&str>,
2021    start: Option<i32>,
2022) -> Result<crate::models::PaginatedOwnerGroupList, Error<UsersOwnerGroupsListError>> {
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/users/owner-groups/",
2029        local_var_configuration.base_path
2030    );
2031    let mut local_var_req_builder =
2032        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2033
2034    if let Some(ref local_var_str) = description {
2035        local_var_req_builder = match "multi" {
2036            "multi" => local_var_req_builder.query(
2037                &local_var_str
2038                    .into_iter()
2039                    .map(|p| ("description".to_owned(), p.to_string()))
2040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2041            ),
2042            _ => local_var_req_builder.query(&[(
2043                "description",
2044                &local_var_str
2045                    .into_iter()
2046                    .map(|p| p.to_string())
2047                    .collect::<Vec<String>>()
2048                    .join(",")
2049                    .to_string(),
2050            )]),
2051        };
2052    }
2053    if let Some(ref local_var_str) = description__empty {
2054        local_var_req_builder =
2055            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2056    }
2057    if let Some(ref local_var_str) = description__ic {
2058        local_var_req_builder = match "multi" {
2059            "multi" => local_var_req_builder.query(
2060                &local_var_str
2061                    .into_iter()
2062                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2064            ),
2065            _ => local_var_req_builder.query(&[(
2066                "description__ic",
2067                &local_var_str
2068                    .into_iter()
2069                    .map(|p| p.to_string())
2070                    .collect::<Vec<String>>()
2071                    .join(",")
2072                    .to_string(),
2073            )]),
2074        };
2075    }
2076    if let Some(ref local_var_str) = description__ie {
2077        local_var_req_builder = match "multi" {
2078            "multi" => local_var_req_builder.query(
2079                &local_var_str
2080                    .into_iter()
2081                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2083            ),
2084            _ => local_var_req_builder.query(&[(
2085                "description__ie",
2086                &local_var_str
2087                    .into_iter()
2088                    .map(|p| p.to_string())
2089                    .collect::<Vec<String>>()
2090                    .join(",")
2091                    .to_string(),
2092            )]),
2093        };
2094    }
2095    if let Some(ref local_var_str) = description__iew {
2096        local_var_req_builder = match "multi" {
2097            "multi" => local_var_req_builder.query(
2098                &local_var_str
2099                    .into_iter()
2100                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2102            ),
2103            _ => local_var_req_builder.query(&[(
2104                "description__iew",
2105                &local_var_str
2106                    .into_iter()
2107                    .map(|p| p.to_string())
2108                    .collect::<Vec<String>>()
2109                    .join(",")
2110                    .to_string(),
2111            )]),
2112        };
2113    }
2114    if let Some(ref local_var_str) = description__iregex {
2115        local_var_req_builder = match "multi" {
2116            "multi" => local_var_req_builder.query(
2117                &local_var_str
2118                    .into_iter()
2119                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2121            ),
2122            _ => local_var_req_builder.query(&[(
2123                "description__iregex",
2124                &local_var_str
2125                    .into_iter()
2126                    .map(|p| p.to_string())
2127                    .collect::<Vec<String>>()
2128                    .join(",")
2129                    .to_string(),
2130            )]),
2131        };
2132    }
2133    if let Some(ref local_var_str) = description__isw {
2134        local_var_req_builder = match "multi" {
2135            "multi" => local_var_req_builder.query(
2136                &local_var_str
2137                    .into_iter()
2138                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2140            ),
2141            _ => local_var_req_builder.query(&[(
2142                "description__isw",
2143                &local_var_str
2144                    .into_iter()
2145                    .map(|p| p.to_string())
2146                    .collect::<Vec<String>>()
2147                    .join(",")
2148                    .to_string(),
2149            )]),
2150        };
2151    }
2152    if let Some(ref local_var_str) = description__n {
2153        local_var_req_builder = match "multi" {
2154            "multi" => local_var_req_builder.query(
2155                &local_var_str
2156                    .into_iter()
2157                    .map(|p| ("description__n".to_owned(), p.to_string()))
2158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2159            ),
2160            _ => local_var_req_builder.query(&[(
2161                "description__n",
2162                &local_var_str
2163                    .into_iter()
2164                    .map(|p| p.to_string())
2165                    .collect::<Vec<String>>()
2166                    .join(",")
2167                    .to_string(),
2168            )]),
2169        };
2170    }
2171    if let Some(ref local_var_str) = description__nic {
2172        local_var_req_builder = match "multi" {
2173            "multi" => local_var_req_builder.query(
2174                &local_var_str
2175                    .into_iter()
2176                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2178            ),
2179            _ => local_var_req_builder.query(&[(
2180                "description__nic",
2181                &local_var_str
2182                    .into_iter()
2183                    .map(|p| p.to_string())
2184                    .collect::<Vec<String>>()
2185                    .join(",")
2186                    .to_string(),
2187            )]),
2188        };
2189    }
2190    if let Some(ref local_var_str) = description__nie {
2191        local_var_req_builder = match "multi" {
2192            "multi" => local_var_req_builder.query(
2193                &local_var_str
2194                    .into_iter()
2195                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2197            ),
2198            _ => local_var_req_builder.query(&[(
2199                "description__nie",
2200                &local_var_str
2201                    .into_iter()
2202                    .map(|p| p.to_string())
2203                    .collect::<Vec<String>>()
2204                    .join(",")
2205                    .to_string(),
2206            )]),
2207        };
2208    }
2209    if let Some(ref local_var_str) = description__niew {
2210        local_var_req_builder = match "multi" {
2211            "multi" => local_var_req_builder.query(
2212                &local_var_str
2213                    .into_iter()
2214                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2216            ),
2217            _ => local_var_req_builder.query(&[(
2218                "description__niew",
2219                &local_var_str
2220                    .into_iter()
2221                    .map(|p| p.to_string())
2222                    .collect::<Vec<String>>()
2223                    .join(",")
2224                    .to_string(),
2225            )]),
2226        };
2227    }
2228    if let Some(ref local_var_str) = description__nisw {
2229        local_var_req_builder = match "multi" {
2230            "multi" => local_var_req_builder.query(
2231                &local_var_str
2232                    .into_iter()
2233                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2235            ),
2236            _ => local_var_req_builder.query(&[(
2237                "description__nisw",
2238                &local_var_str
2239                    .into_iter()
2240                    .map(|p| p.to_string())
2241                    .collect::<Vec<String>>()
2242                    .join(",")
2243                    .to_string(),
2244            )]),
2245        };
2246    }
2247    if let Some(ref local_var_str) = description__regex {
2248        local_var_req_builder = match "multi" {
2249            "multi" => local_var_req_builder.query(
2250                &local_var_str
2251                    .into_iter()
2252                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2254            ),
2255            _ => local_var_req_builder.query(&[(
2256                "description__regex",
2257                &local_var_str
2258                    .into_iter()
2259                    .map(|p| p.to_string())
2260                    .collect::<Vec<String>>()
2261                    .join(",")
2262                    .to_string(),
2263            )]),
2264        };
2265    }
2266    if let Some(ref local_var_str) = id {
2267        local_var_req_builder = match "multi" {
2268            "multi" => local_var_req_builder.query(
2269                &local_var_str
2270                    .into_iter()
2271                    .map(|p| ("id".to_owned(), p.to_string()))
2272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2273            ),
2274            _ => local_var_req_builder.query(&[(
2275                "id",
2276                &local_var_str
2277                    .into_iter()
2278                    .map(|p| p.to_string())
2279                    .collect::<Vec<String>>()
2280                    .join(",")
2281                    .to_string(),
2282            )]),
2283        };
2284    }
2285    if let Some(ref local_var_str) = id__empty {
2286        local_var_req_builder =
2287            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2288    }
2289    if let Some(ref local_var_str) = id__gt {
2290        local_var_req_builder = match "multi" {
2291            "multi" => local_var_req_builder.query(
2292                &local_var_str
2293                    .into_iter()
2294                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2296            ),
2297            _ => local_var_req_builder.query(&[(
2298                "id__gt",
2299                &local_var_str
2300                    .into_iter()
2301                    .map(|p| p.to_string())
2302                    .collect::<Vec<String>>()
2303                    .join(",")
2304                    .to_string(),
2305            )]),
2306        };
2307    }
2308    if let Some(ref local_var_str) = id__gte {
2309        local_var_req_builder = match "multi" {
2310            "multi" => local_var_req_builder.query(
2311                &local_var_str
2312                    .into_iter()
2313                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2315            ),
2316            _ => local_var_req_builder.query(&[(
2317                "id__gte",
2318                &local_var_str
2319                    .into_iter()
2320                    .map(|p| p.to_string())
2321                    .collect::<Vec<String>>()
2322                    .join(",")
2323                    .to_string(),
2324            )]),
2325        };
2326    }
2327    if let Some(ref local_var_str) = id__lt {
2328        local_var_req_builder = match "multi" {
2329            "multi" => local_var_req_builder.query(
2330                &local_var_str
2331                    .into_iter()
2332                    .map(|p| ("id__lt".to_owned(), p.to_string()))
2333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2334            ),
2335            _ => local_var_req_builder.query(&[(
2336                "id__lt",
2337                &local_var_str
2338                    .into_iter()
2339                    .map(|p| p.to_string())
2340                    .collect::<Vec<String>>()
2341                    .join(",")
2342                    .to_string(),
2343            )]),
2344        };
2345    }
2346    if let Some(ref local_var_str) = id__lte {
2347        local_var_req_builder = match "multi" {
2348            "multi" => local_var_req_builder.query(
2349                &local_var_str
2350                    .into_iter()
2351                    .map(|p| ("id__lte".to_owned(), p.to_string()))
2352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2353            ),
2354            _ => local_var_req_builder.query(&[(
2355                "id__lte",
2356                &local_var_str
2357                    .into_iter()
2358                    .map(|p| p.to_string())
2359                    .collect::<Vec<String>>()
2360                    .join(",")
2361                    .to_string(),
2362            )]),
2363        };
2364    }
2365    if let Some(ref local_var_str) = id__n {
2366        local_var_req_builder = match "multi" {
2367            "multi" => local_var_req_builder.query(
2368                &local_var_str
2369                    .into_iter()
2370                    .map(|p| ("id__n".to_owned(), p.to_string()))
2371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2372            ),
2373            _ => local_var_req_builder.query(&[(
2374                "id__n",
2375                &local_var_str
2376                    .into_iter()
2377                    .map(|p| p.to_string())
2378                    .collect::<Vec<String>>()
2379                    .join(",")
2380                    .to_string(),
2381            )]),
2382        };
2383    }
2384    if let Some(ref local_var_str) = limit {
2385        local_var_req_builder =
2386            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
2387    }
2388    if let Some(ref local_var_str) = name {
2389        local_var_req_builder = match "multi" {
2390            "multi" => local_var_req_builder.query(
2391                &local_var_str
2392                    .into_iter()
2393                    .map(|p| ("name".to_owned(), p.to_string()))
2394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2395            ),
2396            _ => local_var_req_builder.query(&[(
2397                "name",
2398                &local_var_str
2399                    .into_iter()
2400                    .map(|p| p.to_string())
2401                    .collect::<Vec<String>>()
2402                    .join(",")
2403                    .to_string(),
2404            )]),
2405        };
2406    }
2407    if let Some(ref local_var_str) = name__empty {
2408        local_var_req_builder =
2409            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
2410    }
2411    if let Some(ref local_var_str) = name__ic {
2412        local_var_req_builder = match "multi" {
2413            "multi" => local_var_req_builder.query(
2414                &local_var_str
2415                    .into_iter()
2416                    .map(|p| ("name__ic".to_owned(), p.to_string()))
2417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2418            ),
2419            _ => local_var_req_builder.query(&[(
2420                "name__ic",
2421                &local_var_str
2422                    .into_iter()
2423                    .map(|p| p.to_string())
2424                    .collect::<Vec<String>>()
2425                    .join(",")
2426                    .to_string(),
2427            )]),
2428        };
2429    }
2430    if let Some(ref local_var_str) = name__ie {
2431        local_var_req_builder = match "multi" {
2432            "multi" => local_var_req_builder.query(
2433                &local_var_str
2434                    .into_iter()
2435                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2437            ),
2438            _ => local_var_req_builder.query(&[(
2439                "name__ie",
2440                &local_var_str
2441                    .into_iter()
2442                    .map(|p| p.to_string())
2443                    .collect::<Vec<String>>()
2444                    .join(",")
2445                    .to_string(),
2446            )]),
2447        };
2448    }
2449    if let Some(ref local_var_str) = name__iew {
2450        local_var_req_builder = match "multi" {
2451            "multi" => local_var_req_builder.query(
2452                &local_var_str
2453                    .into_iter()
2454                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2456            ),
2457            _ => local_var_req_builder.query(&[(
2458                "name__iew",
2459                &local_var_str
2460                    .into_iter()
2461                    .map(|p| p.to_string())
2462                    .collect::<Vec<String>>()
2463                    .join(",")
2464                    .to_string(),
2465            )]),
2466        };
2467    }
2468    if let Some(ref local_var_str) = name__iregex {
2469        local_var_req_builder = match "multi" {
2470            "multi" => local_var_req_builder.query(
2471                &local_var_str
2472                    .into_iter()
2473                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
2474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2475            ),
2476            _ => local_var_req_builder.query(&[(
2477                "name__iregex",
2478                &local_var_str
2479                    .into_iter()
2480                    .map(|p| p.to_string())
2481                    .collect::<Vec<String>>()
2482                    .join(",")
2483                    .to_string(),
2484            )]),
2485        };
2486    }
2487    if let Some(ref local_var_str) = name__isw {
2488        local_var_req_builder = match "multi" {
2489            "multi" => local_var_req_builder.query(
2490                &local_var_str
2491                    .into_iter()
2492                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2494            ),
2495            _ => local_var_req_builder.query(&[(
2496                "name__isw",
2497                &local_var_str
2498                    .into_iter()
2499                    .map(|p| p.to_string())
2500                    .collect::<Vec<String>>()
2501                    .join(",")
2502                    .to_string(),
2503            )]),
2504        };
2505    }
2506    if let Some(ref local_var_str) = name__n {
2507        local_var_req_builder = match "multi" {
2508            "multi" => local_var_req_builder.query(
2509                &local_var_str
2510                    .into_iter()
2511                    .map(|p| ("name__n".to_owned(), p.to_string()))
2512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2513            ),
2514            _ => local_var_req_builder.query(&[(
2515                "name__n",
2516                &local_var_str
2517                    .into_iter()
2518                    .map(|p| p.to_string())
2519                    .collect::<Vec<String>>()
2520                    .join(",")
2521                    .to_string(),
2522            )]),
2523        };
2524    }
2525    if let Some(ref local_var_str) = name__nic {
2526        local_var_req_builder = match "multi" {
2527            "multi" => local_var_req_builder.query(
2528                &local_var_str
2529                    .into_iter()
2530                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2532            ),
2533            _ => local_var_req_builder.query(&[(
2534                "name__nic",
2535                &local_var_str
2536                    .into_iter()
2537                    .map(|p| p.to_string())
2538                    .collect::<Vec<String>>()
2539                    .join(",")
2540                    .to_string(),
2541            )]),
2542        };
2543    }
2544    if let Some(ref local_var_str) = name__nie {
2545        local_var_req_builder = match "multi" {
2546            "multi" => local_var_req_builder.query(
2547                &local_var_str
2548                    .into_iter()
2549                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2551            ),
2552            _ => local_var_req_builder.query(&[(
2553                "name__nie",
2554                &local_var_str
2555                    .into_iter()
2556                    .map(|p| p.to_string())
2557                    .collect::<Vec<String>>()
2558                    .join(",")
2559                    .to_string(),
2560            )]),
2561        };
2562    }
2563    if let Some(ref local_var_str) = name__niew {
2564        local_var_req_builder = match "multi" {
2565            "multi" => local_var_req_builder.query(
2566                &local_var_str
2567                    .into_iter()
2568                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2570            ),
2571            _ => local_var_req_builder.query(&[(
2572                "name__niew",
2573                &local_var_str
2574                    .into_iter()
2575                    .map(|p| p.to_string())
2576                    .collect::<Vec<String>>()
2577                    .join(",")
2578                    .to_string(),
2579            )]),
2580        };
2581    }
2582    if let Some(ref local_var_str) = name__nisw {
2583        local_var_req_builder = match "multi" {
2584            "multi" => local_var_req_builder.query(
2585                &local_var_str
2586                    .into_iter()
2587                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2589            ),
2590            _ => local_var_req_builder.query(&[(
2591                "name__nisw",
2592                &local_var_str
2593                    .into_iter()
2594                    .map(|p| p.to_string())
2595                    .collect::<Vec<String>>()
2596                    .join(",")
2597                    .to_string(),
2598            )]),
2599        };
2600    }
2601    if let Some(ref local_var_str) = name__regex {
2602        local_var_req_builder = match "multi" {
2603            "multi" => local_var_req_builder.query(
2604                &local_var_str
2605                    .into_iter()
2606                    .map(|p| ("name__regex".to_owned(), p.to_string()))
2607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2608            ),
2609            _ => local_var_req_builder.query(&[(
2610                "name__regex",
2611                &local_var_str
2612                    .into_iter()
2613                    .map(|p| p.to_string())
2614                    .collect::<Vec<String>>()
2615                    .join(",")
2616                    .to_string(),
2617            )]),
2618        };
2619    }
2620    if let Some(ref local_var_str) = offset {
2621        local_var_req_builder =
2622            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2623    }
2624    if let Some(ref local_var_str) = ordering {
2625        local_var_req_builder =
2626            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
2627    }
2628    if let Some(ref local_var_str) = q {
2629        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2630    }
2631    if let Some(ref local_var_str) = start {
2632        local_var_req_builder =
2633            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
2634    }
2635    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2636        local_var_req_builder =
2637            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2638    }
2639    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2640        let local_var_key = local_var_apikey.key.clone();
2641        let local_var_value = match local_var_apikey.prefix {
2642            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2643            None => local_var_key,
2644        };
2645        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2646    };
2647
2648    let local_var_req = local_var_req_builder.build()?;
2649    let local_var_resp = local_var_client.execute(local_var_req).await?;
2650
2651    let local_var_status = local_var_resp.status();
2652    let local_var_content = local_var_resp.text().await?;
2653
2654    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2655        serde_json::from_str(&local_var_content).map_err(Error::from)
2656    } else {
2657        let local_var_entity: Option<UsersOwnerGroupsListError> =
2658            serde_json::from_str(&local_var_content).ok();
2659        let local_var_error = ResponseContent {
2660            status: local_var_status,
2661            content: local_var_content,
2662            entity: local_var_entity,
2663        };
2664        Err(Error::ResponseError(local_var_error))
2665    }
2666}
2667
2668/// Patch a owner group object.
2669pub async fn users_owner_groups_partial_update(
2670    configuration: &configuration::Configuration,
2671    id: i32,
2672    patched_owner_group_request: Option<crate::models::PatchedOwnerGroupRequest>,
2673) -> Result<crate::models::OwnerGroup, Error<UsersOwnerGroupsPartialUpdateError>> {
2674    let local_var_configuration = configuration;
2675
2676    let local_var_client = &local_var_configuration.client;
2677
2678    let local_var_uri_str = format!(
2679        "{}/api/users/owner-groups/{id}/",
2680        local_var_configuration.base_path,
2681        id = id
2682    );
2683    let mut local_var_req_builder =
2684        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2685
2686    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2687        local_var_req_builder =
2688            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2689    }
2690    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2691        let local_var_key = local_var_apikey.key.clone();
2692        let local_var_value = match local_var_apikey.prefix {
2693            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2694            None => local_var_key,
2695        };
2696        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2697    };
2698    local_var_req_builder = local_var_req_builder.json(&patched_owner_group_request);
2699
2700    let local_var_req = local_var_req_builder.build()?;
2701    let local_var_resp = local_var_client.execute(local_var_req).await?;
2702
2703    let local_var_status = local_var_resp.status();
2704    let local_var_content = local_var_resp.text().await?;
2705
2706    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2707        serde_json::from_str(&local_var_content).map_err(Error::from)
2708    } else {
2709        let local_var_entity: Option<UsersOwnerGroupsPartialUpdateError> =
2710            serde_json::from_str(&local_var_content).ok();
2711        let local_var_error = ResponseContent {
2712            status: local_var_status,
2713            content: local_var_content,
2714            entity: local_var_entity,
2715        };
2716        Err(Error::ResponseError(local_var_error))
2717    }
2718}
2719
2720/// Get a owner group object.
2721pub async fn users_owner_groups_retrieve(
2722    configuration: &configuration::Configuration,
2723    id: i32,
2724) -> Result<crate::models::OwnerGroup, Error<UsersOwnerGroupsRetrieveError>> {
2725    let local_var_configuration = configuration;
2726
2727    let local_var_client = &local_var_configuration.client;
2728
2729    let local_var_uri_str = format!(
2730        "{}/api/users/owner-groups/{id}/",
2731        local_var_configuration.base_path,
2732        id = id
2733    );
2734    let mut local_var_req_builder =
2735        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2736
2737    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2738        local_var_req_builder =
2739            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2740    }
2741    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2742        let local_var_key = local_var_apikey.key.clone();
2743        let local_var_value = match local_var_apikey.prefix {
2744            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2745            None => local_var_key,
2746        };
2747        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2748    };
2749
2750    let local_var_req = local_var_req_builder.build()?;
2751    let local_var_resp = local_var_client.execute(local_var_req).await?;
2752
2753    let local_var_status = local_var_resp.status();
2754    let local_var_content = local_var_resp.text().await?;
2755
2756    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2757        serde_json::from_str(&local_var_content).map_err(Error::from)
2758    } else {
2759        let local_var_entity: Option<UsersOwnerGroupsRetrieveError> =
2760            serde_json::from_str(&local_var_content).ok();
2761        let local_var_error = ResponseContent {
2762            status: local_var_status,
2763            content: local_var_content,
2764            entity: local_var_entity,
2765        };
2766        Err(Error::ResponseError(local_var_error))
2767    }
2768}
2769
2770/// Put a owner group object.
2771pub async fn users_owner_groups_update(
2772    configuration: &configuration::Configuration,
2773    id: i32,
2774    owner_group_request: crate::models::OwnerGroupRequest,
2775) -> Result<crate::models::OwnerGroup, Error<UsersOwnerGroupsUpdateError>> {
2776    let local_var_configuration = configuration;
2777
2778    let local_var_client = &local_var_configuration.client;
2779
2780    let local_var_uri_str = format!(
2781        "{}/api/users/owner-groups/{id}/",
2782        local_var_configuration.base_path,
2783        id = id
2784    );
2785    let mut local_var_req_builder =
2786        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2787
2788    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2789        local_var_req_builder =
2790            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2791    }
2792    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2793        let local_var_key = local_var_apikey.key.clone();
2794        let local_var_value = match local_var_apikey.prefix {
2795            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2796            None => local_var_key,
2797        };
2798        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2799    };
2800    local_var_req_builder = local_var_req_builder.json(&owner_group_request);
2801
2802    let local_var_req = local_var_req_builder.build()?;
2803    let local_var_resp = local_var_client.execute(local_var_req).await?;
2804
2805    let local_var_status = local_var_resp.status();
2806    let local_var_content = local_var_resp.text().await?;
2807
2808    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2809        serde_json::from_str(&local_var_content).map_err(Error::from)
2810    } else {
2811        let local_var_entity: Option<UsersOwnerGroupsUpdateError> =
2812            serde_json::from_str(&local_var_content).ok();
2813        let local_var_error = ResponseContent {
2814            status: local_var_status,
2815            content: local_var_content,
2816            entity: local_var_entity,
2817        };
2818        Err(Error::ResponseError(local_var_error))
2819    }
2820}
2821
2822/// Delete a list of owner objects.
2823pub async fn users_owners_bulk_destroy(
2824    configuration: &configuration::Configuration,
2825    owner_request: Vec<crate::models::OwnerRequest>,
2826) -> Result<(), Error<UsersOwnersBulkDestroyError>> {
2827    let local_var_configuration = configuration;
2828
2829    let local_var_client = &local_var_configuration.client;
2830
2831    let local_var_uri_str = format!("{}/api/users/owners/", local_var_configuration.base_path);
2832    let mut local_var_req_builder =
2833        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2834
2835    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2836        local_var_req_builder =
2837            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2838    }
2839    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2840        let local_var_key = local_var_apikey.key.clone();
2841        let local_var_value = match local_var_apikey.prefix {
2842            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2843            None => local_var_key,
2844        };
2845        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2846    };
2847    local_var_req_builder = local_var_req_builder.json(&owner_request);
2848
2849    let local_var_req = local_var_req_builder.build()?;
2850    let local_var_resp = local_var_client.execute(local_var_req).await?;
2851
2852    let local_var_status = local_var_resp.status();
2853    let local_var_content = local_var_resp.text().await?;
2854
2855    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2856        Ok(())
2857    } else {
2858        let local_var_entity: Option<UsersOwnersBulkDestroyError> =
2859            serde_json::from_str(&local_var_content).ok();
2860        let local_var_error = ResponseContent {
2861            status: local_var_status,
2862            content: local_var_content,
2863            entity: local_var_entity,
2864        };
2865        Err(Error::ResponseError(local_var_error))
2866    }
2867}
2868
2869/// Patch a list of owner objects.
2870pub async fn users_owners_bulk_partial_update(
2871    configuration: &configuration::Configuration,
2872    owner_request: Vec<crate::models::OwnerRequest>,
2873) -> Result<Vec<crate::models::Owner>, Error<UsersOwnersBulkPartialUpdateError>> {
2874    let local_var_configuration = configuration;
2875
2876    let local_var_client = &local_var_configuration.client;
2877
2878    let local_var_uri_str = format!("{}/api/users/owners/", local_var_configuration.base_path);
2879    let mut local_var_req_builder =
2880        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2881
2882    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2883        local_var_req_builder =
2884            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2885    }
2886    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2887        let local_var_key = local_var_apikey.key.clone();
2888        let local_var_value = match local_var_apikey.prefix {
2889            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2890            None => local_var_key,
2891        };
2892        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2893    };
2894    local_var_req_builder = local_var_req_builder.json(&owner_request);
2895
2896    let local_var_req = local_var_req_builder.build()?;
2897    let local_var_resp = local_var_client.execute(local_var_req).await?;
2898
2899    let local_var_status = local_var_resp.status();
2900    let local_var_content = local_var_resp.text().await?;
2901
2902    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2903        serde_json::from_str(&local_var_content).map_err(Error::from)
2904    } else {
2905        let local_var_entity: Option<UsersOwnersBulkPartialUpdateError> =
2906            serde_json::from_str(&local_var_content).ok();
2907        let local_var_error = ResponseContent {
2908            status: local_var_status,
2909            content: local_var_content,
2910            entity: local_var_entity,
2911        };
2912        Err(Error::ResponseError(local_var_error))
2913    }
2914}
2915
2916/// Put a list of owner objects.
2917pub async fn users_owners_bulk_update(
2918    configuration: &configuration::Configuration,
2919    owner_request: Vec<crate::models::OwnerRequest>,
2920) -> Result<Vec<crate::models::Owner>, Error<UsersOwnersBulkUpdateError>> {
2921    let local_var_configuration = configuration;
2922
2923    let local_var_client = &local_var_configuration.client;
2924
2925    let local_var_uri_str = format!("{}/api/users/owners/", local_var_configuration.base_path);
2926    let mut local_var_req_builder =
2927        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2928
2929    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2930        local_var_req_builder =
2931            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2932    }
2933    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2934        let local_var_key = local_var_apikey.key.clone();
2935        let local_var_value = match local_var_apikey.prefix {
2936            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2937            None => local_var_key,
2938        };
2939        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2940    };
2941    local_var_req_builder = local_var_req_builder.json(&owner_request);
2942
2943    let local_var_req = local_var_req_builder.build()?;
2944    let local_var_resp = local_var_client.execute(local_var_req).await?;
2945
2946    let local_var_status = local_var_resp.status();
2947    let local_var_content = local_var_resp.text().await?;
2948
2949    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2950        serde_json::from_str(&local_var_content).map_err(Error::from)
2951    } else {
2952        let local_var_entity: Option<UsersOwnersBulkUpdateError> =
2953            serde_json::from_str(&local_var_content).ok();
2954        let local_var_error = ResponseContent {
2955            status: local_var_status,
2956            content: local_var_content,
2957            entity: local_var_entity,
2958        };
2959        Err(Error::ResponseError(local_var_error))
2960    }
2961}
2962
2963/// Post a list of owner objects.
2964pub async fn users_owners_create(
2965    configuration: &configuration::Configuration,
2966    users_owners_create_request: crate::models::UsersOwnersCreateRequest,
2967) -> Result<crate::models::Owner, Error<UsersOwnersCreateError>> {
2968    let local_var_configuration = configuration;
2969
2970    let local_var_client = &local_var_configuration.client;
2971
2972    let local_var_uri_str = format!("{}/api/users/owners/", local_var_configuration.base_path);
2973    let mut local_var_req_builder =
2974        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2975
2976    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2977        local_var_req_builder =
2978            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2979    }
2980    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2981        let local_var_key = local_var_apikey.key.clone();
2982        let local_var_value = match local_var_apikey.prefix {
2983            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2984            None => local_var_key,
2985        };
2986        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2987    };
2988    local_var_req_builder = local_var_req_builder.json(&users_owners_create_request);
2989
2990    let local_var_req = local_var_req_builder.build()?;
2991    let local_var_resp = local_var_client.execute(local_var_req).await?;
2992
2993    let local_var_status = local_var_resp.status();
2994    let local_var_content = local_var_resp.text().await?;
2995
2996    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2997        serde_json::from_str(&local_var_content).map_err(Error::from)
2998    } else {
2999        let local_var_entity: Option<UsersOwnersCreateError> =
3000            serde_json::from_str(&local_var_content).ok();
3001        let local_var_error = ResponseContent {
3002            status: local_var_status,
3003            content: local_var_content,
3004            entity: local_var_entity,
3005        };
3006        Err(Error::ResponseError(local_var_error))
3007    }
3008}
3009
3010/// Delete a owner object.
3011pub async fn users_owners_destroy(
3012    configuration: &configuration::Configuration,
3013    id: i32,
3014) -> Result<(), Error<UsersOwnersDestroyError>> {
3015    let local_var_configuration = configuration;
3016
3017    let local_var_client = &local_var_configuration.client;
3018
3019    let local_var_uri_str = format!(
3020        "{}/api/users/owners/{id}/",
3021        local_var_configuration.base_path,
3022        id = id
3023    );
3024    let mut local_var_req_builder =
3025        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3026
3027    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3028        local_var_req_builder =
3029            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3030    }
3031    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3032        let local_var_key = local_var_apikey.key.clone();
3033        let local_var_value = match local_var_apikey.prefix {
3034            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3035            None => local_var_key,
3036        };
3037        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3038    };
3039
3040    let local_var_req = local_var_req_builder.build()?;
3041    let local_var_resp = local_var_client.execute(local_var_req).await?;
3042
3043    let local_var_status = local_var_resp.status();
3044    let local_var_content = local_var_resp.text().await?;
3045
3046    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3047        Ok(())
3048    } else {
3049        let local_var_entity: Option<UsersOwnersDestroyError> =
3050            serde_json::from_str(&local_var_content).ok();
3051        let local_var_error = ResponseContent {
3052            status: local_var_status,
3053            content: local_var_content,
3054            entity: local_var_entity,
3055        };
3056        Err(Error::ResponseError(local_var_error))
3057    }
3058}
3059
3060/// Get a list of owner objects.
3061pub async fn users_owners_list(
3062    configuration: &configuration::Configuration,
3063    description: Option<Vec<String>>,
3064    description__empty: Option<bool>,
3065    description__ic: Option<Vec<String>>,
3066    description__ie: Option<Vec<String>>,
3067    description__iew: Option<Vec<String>>,
3068    description__iregex: Option<Vec<String>>,
3069    description__isw: Option<Vec<String>>,
3070    description__n: Option<Vec<String>>,
3071    description__nic: Option<Vec<String>>,
3072    description__nie: Option<Vec<String>>,
3073    description__niew: Option<Vec<String>>,
3074    description__nisw: Option<Vec<String>>,
3075    description__regex: Option<Vec<String>>,
3076    group: Option<Vec<String>>,
3077    group__n: Option<Vec<String>>,
3078    group_id: Option<Vec<i32>>,
3079    group_id__n: Option<Vec<i32>>,
3080    id: Option<Vec<i32>>,
3081    id__empty: Option<bool>,
3082    id__gt: Option<Vec<i32>>,
3083    id__gte: Option<Vec<i32>>,
3084    id__lt: Option<Vec<i32>>,
3085    id__lte: Option<Vec<i32>>,
3086    id__n: Option<Vec<i32>>,
3087    limit: Option<i32>,
3088    name: Option<Vec<String>>,
3089    name__empty: Option<bool>,
3090    name__ic: Option<Vec<String>>,
3091    name__ie: Option<Vec<String>>,
3092    name__iew: Option<Vec<String>>,
3093    name__iregex: Option<Vec<String>>,
3094    name__isw: Option<Vec<String>>,
3095    name__n: Option<Vec<String>>,
3096    name__nic: Option<Vec<String>>,
3097    name__nie: Option<Vec<String>>,
3098    name__niew: Option<Vec<String>>,
3099    name__nisw: Option<Vec<String>>,
3100    name__regex: Option<Vec<String>>,
3101    offset: Option<i32>,
3102    ordering: Option<&str>,
3103    q: Option<&str>,
3104    start: Option<i32>,
3105    user: Option<Vec<String>>,
3106    user__n: Option<Vec<String>>,
3107    user_group: Option<Vec<String>>,
3108    user_group__n: Option<Vec<String>>,
3109    user_group_id: Option<Vec<i32>>,
3110    user_group_id__n: Option<Vec<i32>>,
3111    user_id: Option<Vec<i32>>,
3112    user_id__n: Option<Vec<i32>>,
3113) -> Result<crate::models::PaginatedOwnerList, Error<UsersOwnersListError>> {
3114    let local_var_configuration = configuration;
3115
3116    let local_var_client = &local_var_configuration.client;
3117
3118    let local_var_uri_str = format!("{}/api/users/owners/", local_var_configuration.base_path);
3119    let mut local_var_req_builder =
3120        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3121
3122    if let Some(ref local_var_str) = description {
3123        local_var_req_builder = match "multi" {
3124            "multi" => local_var_req_builder.query(
3125                &local_var_str
3126                    .into_iter()
3127                    .map(|p| ("description".to_owned(), p.to_string()))
3128                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3129            ),
3130            _ => local_var_req_builder.query(&[(
3131                "description",
3132                &local_var_str
3133                    .into_iter()
3134                    .map(|p| p.to_string())
3135                    .collect::<Vec<String>>()
3136                    .join(",")
3137                    .to_string(),
3138            )]),
3139        };
3140    }
3141    if let Some(ref local_var_str) = description__empty {
3142        local_var_req_builder =
3143            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
3144    }
3145    if let Some(ref local_var_str) = description__ic {
3146        local_var_req_builder = match "multi" {
3147            "multi" => local_var_req_builder.query(
3148                &local_var_str
3149                    .into_iter()
3150                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3152            ),
3153            _ => local_var_req_builder.query(&[(
3154                "description__ic",
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) = description__ie {
3165        local_var_req_builder = match "multi" {
3166            "multi" => local_var_req_builder.query(
3167                &local_var_str
3168                    .into_iter()
3169                    .map(|p| ("description__ie".to_owned(), p.to_string()))
3170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3171            ),
3172            _ => local_var_req_builder.query(&[(
3173                "description__ie",
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) = description__iew {
3184        local_var_req_builder = match "multi" {
3185            "multi" => local_var_req_builder.query(
3186                &local_var_str
3187                    .into_iter()
3188                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3190            ),
3191            _ => local_var_req_builder.query(&[(
3192                "description__iew",
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) = description__iregex {
3203        local_var_req_builder = match "multi" {
3204            "multi" => local_var_req_builder.query(
3205                &local_var_str
3206                    .into_iter()
3207                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
3208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3209            ),
3210            _ => local_var_req_builder.query(&[(
3211                "description__iregex",
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) = description__isw {
3222        local_var_req_builder = match "multi" {
3223            "multi" => local_var_req_builder.query(
3224                &local_var_str
3225                    .into_iter()
3226                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3228            ),
3229            _ => local_var_req_builder.query(&[(
3230                "description__isw",
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) = description__n {
3241        local_var_req_builder = match "multi" {
3242            "multi" => local_var_req_builder.query(
3243                &local_var_str
3244                    .into_iter()
3245                    .map(|p| ("description__n".to_owned(), p.to_string()))
3246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3247            ),
3248            _ => local_var_req_builder.query(&[(
3249                "description__n",
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) = description__nic {
3260        local_var_req_builder = match "multi" {
3261            "multi" => local_var_req_builder.query(
3262                &local_var_str
3263                    .into_iter()
3264                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3266            ),
3267            _ => local_var_req_builder.query(&[(
3268                "description__nic",
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) = description__nie {
3279        local_var_req_builder = match "multi" {
3280            "multi" => local_var_req_builder.query(
3281                &local_var_str
3282                    .into_iter()
3283                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3285            ),
3286            _ => local_var_req_builder.query(&[(
3287                "description__nie",
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) = description__niew {
3298        local_var_req_builder = match "multi" {
3299            "multi" => local_var_req_builder.query(
3300                &local_var_str
3301                    .into_iter()
3302                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3304            ),
3305            _ => local_var_req_builder.query(&[(
3306                "description__niew",
3307                &local_var_str
3308                    .into_iter()
3309                    .map(|p| p.to_string())
3310                    .collect::<Vec<String>>()
3311                    .join(",")
3312                    .to_string(),
3313            )]),
3314        };
3315    }
3316    if let Some(ref local_var_str) = description__nisw {
3317        local_var_req_builder = match "multi" {
3318            "multi" => local_var_req_builder.query(
3319                &local_var_str
3320                    .into_iter()
3321                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3323            ),
3324            _ => local_var_req_builder.query(&[(
3325                "description__nisw",
3326                &local_var_str
3327                    .into_iter()
3328                    .map(|p| p.to_string())
3329                    .collect::<Vec<String>>()
3330                    .join(",")
3331                    .to_string(),
3332            )]),
3333        };
3334    }
3335    if let Some(ref local_var_str) = description__regex {
3336        local_var_req_builder = match "multi" {
3337            "multi" => local_var_req_builder.query(
3338                &local_var_str
3339                    .into_iter()
3340                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3342            ),
3343            _ => local_var_req_builder.query(&[(
3344                "description__regex",
3345                &local_var_str
3346                    .into_iter()
3347                    .map(|p| p.to_string())
3348                    .collect::<Vec<String>>()
3349                    .join(",")
3350                    .to_string(),
3351            )]),
3352        };
3353    }
3354    if let Some(ref local_var_str) = group {
3355        local_var_req_builder = match "multi" {
3356            "multi" => local_var_req_builder.query(
3357                &local_var_str
3358                    .into_iter()
3359                    .map(|p| ("group".to_owned(), p.to_string()))
3360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3361            ),
3362            _ => local_var_req_builder.query(&[(
3363                "group",
3364                &local_var_str
3365                    .into_iter()
3366                    .map(|p| p.to_string())
3367                    .collect::<Vec<String>>()
3368                    .join(",")
3369                    .to_string(),
3370            )]),
3371        };
3372    }
3373    if let Some(ref local_var_str) = group__n {
3374        local_var_req_builder = match "multi" {
3375            "multi" => local_var_req_builder.query(
3376                &local_var_str
3377                    .into_iter()
3378                    .map(|p| ("group__n".to_owned(), p.to_string()))
3379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3380            ),
3381            _ => local_var_req_builder.query(&[(
3382                "group__n",
3383                &local_var_str
3384                    .into_iter()
3385                    .map(|p| p.to_string())
3386                    .collect::<Vec<String>>()
3387                    .join(",")
3388                    .to_string(),
3389            )]),
3390        };
3391    }
3392    if let Some(ref local_var_str) = group_id {
3393        local_var_req_builder = match "multi" {
3394            "multi" => local_var_req_builder.query(
3395                &local_var_str
3396                    .into_iter()
3397                    .map(|p| ("group_id".to_owned(), p.to_string()))
3398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3399            ),
3400            _ => local_var_req_builder.query(&[(
3401                "group_id",
3402                &local_var_str
3403                    .into_iter()
3404                    .map(|p| p.to_string())
3405                    .collect::<Vec<String>>()
3406                    .join(",")
3407                    .to_string(),
3408            )]),
3409        };
3410    }
3411    if let Some(ref local_var_str) = group_id__n {
3412        local_var_req_builder = match "multi" {
3413            "multi" => local_var_req_builder.query(
3414                &local_var_str
3415                    .into_iter()
3416                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
3417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3418            ),
3419            _ => local_var_req_builder.query(&[(
3420                "group_id__n",
3421                &local_var_str
3422                    .into_iter()
3423                    .map(|p| p.to_string())
3424                    .collect::<Vec<String>>()
3425                    .join(",")
3426                    .to_string(),
3427            )]),
3428        };
3429    }
3430    if let Some(ref local_var_str) = id {
3431        local_var_req_builder = match "multi" {
3432            "multi" => local_var_req_builder.query(
3433                &local_var_str
3434                    .into_iter()
3435                    .map(|p| ("id".to_owned(), p.to_string()))
3436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3437            ),
3438            _ => local_var_req_builder.query(&[(
3439                "id",
3440                &local_var_str
3441                    .into_iter()
3442                    .map(|p| p.to_string())
3443                    .collect::<Vec<String>>()
3444                    .join(",")
3445                    .to_string(),
3446            )]),
3447        };
3448    }
3449    if let Some(ref local_var_str) = id__empty {
3450        local_var_req_builder =
3451            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
3452    }
3453    if let Some(ref local_var_str) = id__gt {
3454        local_var_req_builder = match "multi" {
3455            "multi" => local_var_req_builder.query(
3456                &local_var_str
3457                    .into_iter()
3458                    .map(|p| ("id__gt".to_owned(), p.to_string()))
3459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3460            ),
3461            _ => local_var_req_builder.query(&[(
3462                "id__gt",
3463                &local_var_str
3464                    .into_iter()
3465                    .map(|p| p.to_string())
3466                    .collect::<Vec<String>>()
3467                    .join(",")
3468                    .to_string(),
3469            )]),
3470        };
3471    }
3472    if let Some(ref local_var_str) = id__gte {
3473        local_var_req_builder = match "multi" {
3474            "multi" => local_var_req_builder.query(
3475                &local_var_str
3476                    .into_iter()
3477                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3479            ),
3480            _ => local_var_req_builder.query(&[(
3481                "id__gte",
3482                &local_var_str
3483                    .into_iter()
3484                    .map(|p| p.to_string())
3485                    .collect::<Vec<String>>()
3486                    .join(",")
3487                    .to_string(),
3488            )]),
3489        };
3490    }
3491    if let Some(ref local_var_str) = id__lt {
3492        local_var_req_builder = match "multi" {
3493            "multi" => local_var_req_builder.query(
3494                &local_var_str
3495                    .into_iter()
3496                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3498            ),
3499            _ => local_var_req_builder.query(&[(
3500                "id__lt",
3501                &local_var_str
3502                    .into_iter()
3503                    .map(|p| p.to_string())
3504                    .collect::<Vec<String>>()
3505                    .join(",")
3506                    .to_string(),
3507            )]),
3508        };
3509    }
3510    if let Some(ref local_var_str) = id__lte {
3511        local_var_req_builder = match "multi" {
3512            "multi" => local_var_req_builder.query(
3513                &local_var_str
3514                    .into_iter()
3515                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3517            ),
3518            _ => local_var_req_builder.query(&[(
3519                "id__lte",
3520                &local_var_str
3521                    .into_iter()
3522                    .map(|p| p.to_string())
3523                    .collect::<Vec<String>>()
3524                    .join(",")
3525                    .to_string(),
3526            )]),
3527        };
3528    }
3529    if let Some(ref local_var_str) = id__n {
3530        local_var_req_builder = match "multi" {
3531            "multi" => local_var_req_builder.query(
3532                &local_var_str
3533                    .into_iter()
3534                    .map(|p| ("id__n".to_owned(), p.to_string()))
3535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3536            ),
3537            _ => local_var_req_builder.query(&[(
3538                "id__n",
3539                &local_var_str
3540                    .into_iter()
3541                    .map(|p| p.to_string())
3542                    .collect::<Vec<String>>()
3543                    .join(",")
3544                    .to_string(),
3545            )]),
3546        };
3547    }
3548    if let Some(ref local_var_str) = limit {
3549        local_var_req_builder =
3550            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3551    }
3552    if let Some(ref local_var_str) = name {
3553        local_var_req_builder = match "multi" {
3554            "multi" => local_var_req_builder.query(
3555                &local_var_str
3556                    .into_iter()
3557                    .map(|p| ("name".to_owned(), p.to_string()))
3558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3559            ),
3560            _ => local_var_req_builder.query(&[(
3561                "name",
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| p.to_string())
3565                    .collect::<Vec<String>>()
3566                    .join(",")
3567                    .to_string(),
3568            )]),
3569        };
3570    }
3571    if let Some(ref local_var_str) = name__empty {
3572        local_var_req_builder =
3573            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3574    }
3575    if let Some(ref local_var_str) = name__ic {
3576        local_var_req_builder = match "multi" {
3577            "multi" => local_var_req_builder.query(
3578                &local_var_str
3579                    .into_iter()
3580                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3582            ),
3583            _ => local_var_req_builder.query(&[(
3584                "name__ic",
3585                &local_var_str
3586                    .into_iter()
3587                    .map(|p| p.to_string())
3588                    .collect::<Vec<String>>()
3589                    .join(",")
3590                    .to_string(),
3591            )]),
3592        };
3593    }
3594    if let Some(ref local_var_str) = name__ie {
3595        local_var_req_builder = match "multi" {
3596            "multi" => local_var_req_builder.query(
3597                &local_var_str
3598                    .into_iter()
3599                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3601            ),
3602            _ => local_var_req_builder.query(&[(
3603                "name__ie",
3604                &local_var_str
3605                    .into_iter()
3606                    .map(|p| p.to_string())
3607                    .collect::<Vec<String>>()
3608                    .join(",")
3609                    .to_string(),
3610            )]),
3611        };
3612    }
3613    if let Some(ref local_var_str) = name__iew {
3614        local_var_req_builder = match "multi" {
3615            "multi" => local_var_req_builder.query(
3616                &local_var_str
3617                    .into_iter()
3618                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3620            ),
3621            _ => local_var_req_builder.query(&[(
3622                "name__iew",
3623                &local_var_str
3624                    .into_iter()
3625                    .map(|p| p.to_string())
3626                    .collect::<Vec<String>>()
3627                    .join(",")
3628                    .to_string(),
3629            )]),
3630        };
3631    }
3632    if let Some(ref local_var_str) = name__iregex {
3633        local_var_req_builder = match "multi" {
3634            "multi" => local_var_req_builder.query(
3635                &local_var_str
3636                    .into_iter()
3637                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3639            ),
3640            _ => local_var_req_builder.query(&[(
3641                "name__iregex",
3642                &local_var_str
3643                    .into_iter()
3644                    .map(|p| p.to_string())
3645                    .collect::<Vec<String>>()
3646                    .join(",")
3647                    .to_string(),
3648            )]),
3649        };
3650    }
3651    if let Some(ref local_var_str) = name__isw {
3652        local_var_req_builder = match "multi" {
3653            "multi" => local_var_req_builder.query(
3654                &local_var_str
3655                    .into_iter()
3656                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3658            ),
3659            _ => local_var_req_builder.query(&[(
3660                "name__isw",
3661                &local_var_str
3662                    .into_iter()
3663                    .map(|p| p.to_string())
3664                    .collect::<Vec<String>>()
3665                    .join(",")
3666                    .to_string(),
3667            )]),
3668        };
3669    }
3670    if let Some(ref local_var_str) = name__n {
3671        local_var_req_builder = match "multi" {
3672            "multi" => local_var_req_builder.query(
3673                &local_var_str
3674                    .into_iter()
3675                    .map(|p| ("name__n".to_owned(), p.to_string()))
3676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3677            ),
3678            _ => local_var_req_builder.query(&[(
3679                "name__n",
3680                &local_var_str
3681                    .into_iter()
3682                    .map(|p| p.to_string())
3683                    .collect::<Vec<String>>()
3684                    .join(",")
3685                    .to_string(),
3686            )]),
3687        };
3688    }
3689    if let Some(ref local_var_str) = name__nic {
3690        local_var_req_builder = match "multi" {
3691            "multi" => local_var_req_builder.query(
3692                &local_var_str
3693                    .into_iter()
3694                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3696            ),
3697            _ => local_var_req_builder.query(&[(
3698                "name__nic",
3699                &local_var_str
3700                    .into_iter()
3701                    .map(|p| p.to_string())
3702                    .collect::<Vec<String>>()
3703                    .join(",")
3704                    .to_string(),
3705            )]),
3706        };
3707    }
3708    if let Some(ref local_var_str) = name__nie {
3709        local_var_req_builder = match "multi" {
3710            "multi" => local_var_req_builder.query(
3711                &local_var_str
3712                    .into_iter()
3713                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3715            ),
3716            _ => local_var_req_builder.query(&[(
3717                "name__nie",
3718                &local_var_str
3719                    .into_iter()
3720                    .map(|p| p.to_string())
3721                    .collect::<Vec<String>>()
3722                    .join(",")
3723                    .to_string(),
3724            )]),
3725        };
3726    }
3727    if let Some(ref local_var_str) = name__niew {
3728        local_var_req_builder = match "multi" {
3729            "multi" => local_var_req_builder.query(
3730                &local_var_str
3731                    .into_iter()
3732                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3734            ),
3735            _ => local_var_req_builder.query(&[(
3736                "name__niew",
3737                &local_var_str
3738                    .into_iter()
3739                    .map(|p| p.to_string())
3740                    .collect::<Vec<String>>()
3741                    .join(",")
3742                    .to_string(),
3743            )]),
3744        };
3745    }
3746    if let Some(ref local_var_str) = name__nisw {
3747        local_var_req_builder = match "multi" {
3748            "multi" => local_var_req_builder.query(
3749                &local_var_str
3750                    .into_iter()
3751                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3753            ),
3754            _ => local_var_req_builder.query(&[(
3755                "name__nisw",
3756                &local_var_str
3757                    .into_iter()
3758                    .map(|p| p.to_string())
3759                    .collect::<Vec<String>>()
3760                    .join(",")
3761                    .to_string(),
3762            )]),
3763        };
3764    }
3765    if let Some(ref local_var_str) = name__regex {
3766        local_var_req_builder = match "multi" {
3767            "multi" => local_var_req_builder.query(
3768                &local_var_str
3769                    .into_iter()
3770                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3772            ),
3773            _ => local_var_req_builder.query(&[(
3774                "name__regex",
3775                &local_var_str
3776                    .into_iter()
3777                    .map(|p| p.to_string())
3778                    .collect::<Vec<String>>()
3779                    .join(",")
3780                    .to_string(),
3781            )]),
3782        };
3783    }
3784    if let Some(ref local_var_str) = offset {
3785        local_var_req_builder =
3786            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3787    }
3788    if let Some(ref local_var_str) = ordering {
3789        local_var_req_builder =
3790            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3791    }
3792    if let Some(ref local_var_str) = q {
3793        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3794    }
3795    if let Some(ref local_var_str) = start {
3796        local_var_req_builder =
3797            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
3798    }
3799    if let Some(ref local_var_str) = user {
3800        local_var_req_builder = match "multi" {
3801            "multi" => local_var_req_builder.query(
3802                &local_var_str
3803                    .into_iter()
3804                    .map(|p| ("user".to_owned(), p.to_string()))
3805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3806            ),
3807            _ => local_var_req_builder.query(&[(
3808                "user",
3809                &local_var_str
3810                    .into_iter()
3811                    .map(|p| p.to_string())
3812                    .collect::<Vec<String>>()
3813                    .join(",")
3814                    .to_string(),
3815            )]),
3816        };
3817    }
3818    if let Some(ref local_var_str) = user__n {
3819        local_var_req_builder = match "multi" {
3820            "multi" => local_var_req_builder.query(
3821                &local_var_str
3822                    .into_iter()
3823                    .map(|p| ("user__n".to_owned(), p.to_string()))
3824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3825            ),
3826            _ => local_var_req_builder.query(&[(
3827                "user__n",
3828                &local_var_str
3829                    .into_iter()
3830                    .map(|p| p.to_string())
3831                    .collect::<Vec<String>>()
3832                    .join(",")
3833                    .to_string(),
3834            )]),
3835        };
3836    }
3837    if let Some(ref local_var_str) = user_group {
3838        local_var_req_builder = match "multi" {
3839            "multi" => local_var_req_builder.query(
3840                &local_var_str
3841                    .into_iter()
3842                    .map(|p| ("user_group".to_owned(), p.to_string()))
3843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3844            ),
3845            _ => local_var_req_builder.query(&[(
3846                "user_group",
3847                &local_var_str
3848                    .into_iter()
3849                    .map(|p| p.to_string())
3850                    .collect::<Vec<String>>()
3851                    .join(",")
3852                    .to_string(),
3853            )]),
3854        };
3855    }
3856    if let Some(ref local_var_str) = user_group__n {
3857        local_var_req_builder = match "multi" {
3858            "multi" => local_var_req_builder.query(
3859                &local_var_str
3860                    .into_iter()
3861                    .map(|p| ("user_group__n".to_owned(), p.to_string()))
3862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3863            ),
3864            _ => local_var_req_builder.query(&[(
3865                "user_group__n",
3866                &local_var_str
3867                    .into_iter()
3868                    .map(|p| p.to_string())
3869                    .collect::<Vec<String>>()
3870                    .join(",")
3871                    .to_string(),
3872            )]),
3873        };
3874    }
3875    if let Some(ref local_var_str) = user_group_id {
3876        local_var_req_builder = match "multi" {
3877            "multi" => local_var_req_builder.query(
3878                &local_var_str
3879                    .into_iter()
3880                    .map(|p| ("user_group_id".to_owned(), p.to_string()))
3881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3882            ),
3883            _ => local_var_req_builder.query(&[(
3884                "user_group_id",
3885                &local_var_str
3886                    .into_iter()
3887                    .map(|p| p.to_string())
3888                    .collect::<Vec<String>>()
3889                    .join(",")
3890                    .to_string(),
3891            )]),
3892        };
3893    }
3894    if let Some(ref local_var_str) = user_group_id__n {
3895        local_var_req_builder = match "multi" {
3896            "multi" => local_var_req_builder.query(
3897                &local_var_str
3898                    .into_iter()
3899                    .map(|p| ("user_group_id__n".to_owned(), p.to_string()))
3900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3901            ),
3902            _ => local_var_req_builder.query(&[(
3903                "user_group_id__n",
3904                &local_var_str
3905                    .into_iter()
3906                    .map(|p| p.to_string())
3907                    .collect::<Vec<String>>()
3908                    .join(",")
3909                    .to_string(),
3910            )]),
3911        };
3912    }
3913    if let Some(ref local_var_str) = user_id {
3914        local_var_req_builder = match "multi" {
3915            "multi" => local_var_req_builder.query(
3916                &local_var_str
3917                    .into_iter()
3918                    .map(|p| ("user_id".to_owned(), p.to_string()))
3919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3920            ),
3921            _ => local_var_req_builder.query(&[(
3922                "user_id",
3923                &local_var_str
3924                    .into_iter()
3925                    .map(|p| p.to_string())
3926                    .collect::<Vec<String>>()
3927                    .join(",")
3928                    .to_string(),
3929            )]),
3930        };
3931    }
3932    if let Some(ref local_var_str) = user_id__n {
3933        local_var_req_builder = match "multi" {
3934            "multi" => local_var_req_builder.query(
3935                &local_var_str
3936                    .into_iter()
3937                    .map(|p| ("user_id__n".to_owned(), p.to_string()))
3938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3939            ),
3940            _ => local_var_req_builder.query(&[(
3941                "user_id__n",
3942                &local_var_str
3943                    .into_iter()
3944                    .map(|p| p.to_string())
3945                    .collect::<Vec<String>>()
3946                    .join(",")
3947                    .to_string(),
3948            )]),
3949        };
3950    }
3951    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3952        local_var_req_builder =
3953            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3954    }
3955    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3956        let local_var_key = local_var_apikey.key.clone();
3957        let local_var_value = match local_var_apikey.prefix {
3958            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3959            None => local_var_key,
3960        };
3961        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3962    };
3963
3964    let local_var_req = local_var_req_builder.build()?;
3965    let local_var_resp = local_var_client.execute(local_var_req).await?;
3966
3967    let local_var_status = local_var_resp.status();
3968    let local_var_content = local_var_resp.text().await?;
3969
3970    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3971        serde_json::from_str(&local_var_content).map_err(Error::from)
3972    } else {
3973        let local_var_entity: Option<UsersOwnersListError> =
3974            serde_json::from_str(&local_var_content).ok();
3975        let local_var_error = ResponseContent {
3976            status: local_var_status,
3977            content: local_var_content,
3978            entity: local_var_entity,
3979        };
3980        Err(Error::ResponseError(local_var_error))
3981    }
3982}
3983
3984/// Patch a owner object.
3985pub async fn users_owners_partial_update(
3986    configuration: &configuration::Configuration,
3987    id: i32,
3988    patched_owner_request: Option<crate::models::PatchedOwnerRequest>,
3989) -> Result<crate::models::Owner, Error<UsersOwnersPartialUpdateError>> {
3990    let local_var_configuration = configuration;
3991
3992    let local_var_client = &local_var_configuration.client;
3993
3994    let local_var_uri_str = format!(
3995        "{}/api/users/owners/{id}/",
3996        local_var_configuration.base_path,
3997        id = id
3998    );
3999    let mut local_var_req_builder =
4000        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4001
4002    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4003        local_var_req_builder =
4004            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4005    }
4006    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4007        let local_var_key = local_var_apikey.key.clone();
4008        let local_var_value = match local_var_apikey.prefix {
4009            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4010            None => local_var_key,
4011        };
4012        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4013    };
4014    local_var_req_builder = local_var_req_builder.json(&patched_owner_request);
4015
4016    let local_var_req = local_var_req_builder.build()?;
4017    let local_var_resp = local_var_client.execute(local_var_req).await?;
4018
4019    let local_var_status = local_var_resp.status();
4020    let local_var_content = local_var_resp.text().await?;
4021
4022    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4023        serde_json::from_str(&local_var_content).map_err(Error::from)
4024    } else {
4025        let local_var_entity: Option<UsersOwnersPartialUpdateError> =
4026            serde_json::from_str(&local_var_content).ok();
4027        let local_var_error = ResponseContent {
4028            status: local_var_status,
4029            content: local_var_content,
4030            entity: local_var_entity,
4031        };
4032        Err(Error::ResponseError(local_var_error))
4033    }
4034}
4035
4036/// Get a owner object.
4037pub async fn users_owners_retrieve(
4038    configuration: &configuration::Configuration,
4039    id: i32,
4040) -> Result<crate::models::Owner, Error<UsersOwnersRetrieveError>> {
4041    let local_var_configuration = configuration;
4042
4043    let local_var_client = &local_var_configuration.client;
4044
4045    let local_var_uri_str = format!(
4046        "{}/api/users/owners/{id}/",
4047        local_var_configuration.base_path,
4048        id = id
4049    );
4050    let mut local_var_req_builder =
4051        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4052
4053    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4054        local_var_req_builder =
4055            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4056    }
4057    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4058        let local_var_key = local_var_apikey.key.clone();
4059        let local_var_value = match local_var_apikey.prefix {
4060            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4061            None => local_var_key,
4062        };
4063        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4064    };
4065
4066    let local_var_req = local_var_req_builder.build()?;
4067    let local_var_resp = local_var_client.execute(local_var_req).await?;
4068
4069    let local_var_status = local_var_resp.status();
4070    let local_var_content = local_var_resp.text().await?;
4071
4072    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4073        serde_json::from_str(&local_var_content).map_err(Error::from)
4074    } else {
4075        let local_var_entity: Option<UsersOwnersRetrieveError> =
4076            serde_json::from_str(&local_var_content).ok();
4077        let local_var_error = ResponseContent {
4078            status: local_var_status,
4079            content: local_var_content,
4080            entity: local_var_entity,
4081        };
4082        Err(Error::ResponseError(local_var_error))
4083    }
4084}
4085
4086/// Put a owner object.
4087pub async fn users_owners_update(
4088    configuration: &configuration::Configuration,
4089    id: i32,
4090    owner_request: crate::models::OwnerRequest,
4091) -> Result<crate::models::Owner, Error<UsersOwnersUpdateError>> {
4092    let local_var_configuration = configuration;
4093
4094    let local_var_client = &local_var_configuration.client;
4095
4096    let local_var_uri_str = format!(
4097        "{}/api/users/owners/{id}/",
4098        local_var_configuration.base_path,
4099        id = id
4100    );
4101    let mut local_var_req_builder =
4102        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4103
4104    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4105        local_var_req_builder =
4106            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4107    }
4108    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4109        let local_var_key = local_var_apikey.key.clone();
4110        let local_var_value = match local_var_apikey.prefix {
4111            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4112            None => local_var_key,
4113        };
4114        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4115    };
4116    local_var_req_builder = local_var_req_builder.json(&owner_request);
4117
4118    let local_var_req = local_var_req_builder.build()?;
4119    let local_var_resp = local_var_client.execute(local_var_req).await?;
4120
4121    let local_var_status = local_var_resp.status();
4122    let local_var_content = local_var_resp.text().await?;
4123
4124    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4125        serde_json::from_str(&local_var_content).map_err(Error::from)
4126    } else {
4127        let local_var_entity: Option<UsersOwnersUpdateError> =
4128            serde_json::from_str(&local_var_content).ok();
4129        let local_var_error = ResponseContent {
4130            status: local_var_status,
4131            content: local_var_content,
4132            entity: local_var_entity,
4133        };
4134        Err(Error::ResponseError(local_var_error))
4135    }
4136}
4137
4138/// Delete a list of permission objects.
4139pub async fn users_permissions_bulk_destroy(
4140    configuration: &configuration::Configuration,
4141    object_permission_request: Vec<crate::models::ObjectPermissionRequest>,
4142) -> Result<(), Error<UsersPermissionsBulkDestroyError>> {
4143    let local_var_configuration = configuration;
4144
4145    let local_var_client = &local_var_configuration.client;
4146
4147    let local_var_uri_str = format!(
4148        "{}/api/users/permissions/",
4149        local_var_configuration.base_path
4150    );
4151    let mut local_var_req_builder =
4152        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4153
4154    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4155        local_var_req_builder =
4156            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4157    }
4158    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4159        let local_var_key = local_var_apikey.key.clone();
4160        let local_var_value = match local_var_apikey.prefix {
4161            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4162            None => local_var_key,
4163        };
4164        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4165    };
4166    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
4167
4168    let local_var_req = local_var_req_builder.build()?;
4169    let local_var_resp = local_var_client.execute(local_var_req).await?;
4170
4171    let local_var_status = local_var_resp.status();
4172    let local_var_content = local_var_resp.text().await?;
4173
4174    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4175        Ok(())
4176    } else {
4177        let local_var_entity: Option<UsersPermissionsBulkDestroyError> =
4178            serde_json::from_str(&local_var_content).ok();
4179        let local_var_error = ResponseContent {
4180            status: local_var_status,
4181            content: local_var_content,
4182            entity: local_var_entity,
4183        };
4184        Err(Error::ResponseError(local_var_error))
4185    }
4186}
4187
4188/// Patch a list of permission objects.
4189pub async fn users_permissions_bulk_partial_update(
4190    configuration: &configuration::Configuration,
4191    object_permission_request: Vec<crate::models::ObjectPermissionRequest>,
4192) -> Result<Vec<crate::models::ObjectPermission>, Error<UsersPermissionsBulkPartialUpdateError>> {
4193    let local_var_configuration = configuration;
4194
4195    let local_var_client = &local_var_configuration.client;
4196
4197    let local_var_uri_str = format!(
4198        "{}/api/users/permissions/",
4199        local_var_configuration.base_path
4200    );
4201    let mut local_var_req_builder =
4202        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4203
4204    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4205        local_var_req_builder =
4206            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4207    }
4208    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4209        let local_var_key = local_var_apikey.key.clone();
4210        let local_var_value = match local_var_apikey.prefix {
4211            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4212            None => local_var_key,
4213        };
4214        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4215    };
4216    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
4217
4218    let local_var_req = local_var_req_builder.build()?;
4219    let local_var_resp = local_var_client.execute(local_var_req).await?;
4220
4221    let local_var_status = local_var_resp.status();
4222    let local_var_content = local_var_resp.text().await?;
4223
4224    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4225        serde_json::from_str(&local_var_content).map_err(Error::from)
4226    } else {
4227        let local_var_entity: Option<UsersPermissionsBulkPartialUpdateError> =
4228            serde_json::from_str(&local_var_content).ok();
4229        let local_var_error = ResponseContent {
4230            status: local_var_status,
4231            content: local_var_content,
4232            entity: local_var_entity,
4233        };
4234        Err(Error::ResponseError(local_var_error))
4235    }
4236}
4237
4238/// Put a list of permission objects.
4239pub async fn users_permissions_bulk_update(
4240    configuration: &configuration::Configuration,
4241    object_permission_request: Vec<crate::models::ObjectPermissionRequest>,
4242) -> Result<Vec<crate::models::ObjectPermission>, Error<UsersPermissionsBulkUpdateError>> {
4243    let local_var_configuration = configuration;
4244
4245    let local_var_client = &local_var_configuration.client;
4246
4247    let local_var_uri_str = format!(
4248        "{}/api/users/permissions/",
4249        local_var_configuration.base_path
4250    );
4251    let mut local_var_req_builder =
4252        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4253
4254    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4255        local_var_req_builder =
4256            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4257    }
4258    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4259        let local_var_key = local_var_apikey.key.clone();
4260        let local_var_value = match local_var_apikey.prefix {
4261            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4262            None => local_var_key,
4263        };
4264        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4265    };
4266    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
4267
4268    let local_var_req = local_var_req_builder.build()?;
4269    let local_var_resp = local_var_client.execute(local_var_req).await?;
4270
4271    let local_var_status = local_var_resp.status();
4272    let local_var_content = local_var_resp.text().await?;
4273
4274    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4275        serde_json::from_str(&local_var_content).map_err(Error::from)
4276    } else {
4277        let local_var_entity: Option<UsersPermissionsBulkUpdateError> =
4278            serde_json::from_str(&local_var_content).ok();
4279        let local_var_error = ResponseContent {
4280            status: local_var_status,
4281            content: local_var_content,
4282            entity: local_var_entity,
4283        };
4284        Err(Error::ResponseError(local_var_error))
4285    }
4286}
4287
4288/// Post a list of permission objects.
4289pub async fn users_permissions_create(
4290    configuration: &configuration::Configuration,
4291    users_permissions_create_request: crate::models::UsersPermissionsCreateRequest,
4292) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsCreateError>> {
4293    let local_var_configuration = configuration;
4294
4295    let local_var_client = &local_var_configuration.client;
4296
4297    let local_var_uri_str = format!(
4298        "{}/api/users/permissions/",
4299        local_var_configuration.base_path
4300    );
4301    let mut local_var_req_builder =
4302        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4303
4304    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4305        local_var_req_builder =
4306            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4307    }
4308    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4309        let local_var_key = local_var_apikey.key.clone();
4310        let local_var_value = match local_var_apikey.prefix {
4311            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4312            None => local_var_key,
4313        };
4314        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4315    };
4316    local_var_req_builder = local_var_req_builder.json(&users_permissions_create_request);
4317
4318    let local_var_req = local_var_req_builder.build()?;
4319    let local_var_resp = local_var_client.execute(local_var_req).await?;
4320
4321    let local_var_status = local_var_resp.status();
4322    let local_var_content = local_var_resp.text().await?;
4323
4324    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4325        serde_json::from_str(&local_var_content).map_err(Error::from)
4326    } else {
4327        let local_var_entity: Option<UsersPermissionsCreateError> =
4328            serde_json::from_str(&local_var_content).ok();
4329        let local_var_error = ResponseContent {
4330            status: local_var_status,
4331            content: local_var_content,
4332            entity: local_var_entity,
4333        };
4334        Err(Error::ResponseError(local_var_error))
4335    }
4336}
4337
4338/// Delete a permission object.
4339pub async fn users_permissions_destroy(
4340    configuration: &configuration::Configuration,
4341    id: i32,
4342) -> Result<(), Error<UsersPermissionsDestroyError>> {
4343    let local_var_configuration = configuration;
4344
4345    let local_var_client = &local_var_configuration.client;
4346
4347    let local_var_uri_str = format!(
4348        "{}/api/users/permissions/{id}/",
4349        local_var_configuration.base_path,
4350        id = id
4351    );
4352    let mut local_var_req_builder =
4353        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4354
4355    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4356        local_var_req_builder =
4357            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4358    }
4359    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4360        let local_var_key = local_var_apikey.key.clone();
4361        let local_var_value = match local_var_apikey.prefix {
4362            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4363            None => local_var_key,
4364        };
4365        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4366    };
4367
4368    let local_var_req = local_var_req_builder.build()?;
4369    let local_var_resp = local_var_client.execute(local_var_req).await?;
4370
4371    let local_var_status = local_var_resp.status();
4372    let local_var_content = local_var_resp.text().await?;
4373
4374    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4375        Ok(())
4376    } else {
4377        let local_var_entity: Option<UsersPermissionsDestroyError> =
4378            serde_json::from_str(&local_var_content).ok();
4379        let local_var_error = ResponseContent {
4380            status: local_var_status,
4381            content: local_var_content,
4382            entity: local_var_entity,
4383        };
4384        Err(Error::ResponseError(local_var_error))
4385    }
4386}
4387
4388/// Get a list of permission objects.
4389pub async fn users_permissions_list(
4390    configuration: &configuration::Configuration,
4391    can_add: Option<bool>,
4392    can_change: Option<bool>,
4393    can_delete: Option<bool>,
4394    can_view: Option<bool>,
4395    description: Option<Vec<String>>,
4396    description__empty: Option<bool>,
4397    description__ic: Option<Vec<String>>,
4398    description__ie: Option<Vec<String>>,
4399    description__iew: Option<Vec<String>>,
4400    description__iregex: Option<Vec<String>>,
4401    description__isw: Option<Vec<String>>,
4402    description__n: Option<Vec<String>>,
4403    description__nic: Option<Vec<String>>,
4404    description__nie: Option<Vec<String>>,
4405    description__niew: Option<Vec<String>>,
4406    description__nisw: Option<Vec<String>>,
4407    description__regex: Option<Vec<String>>,
4408    enabled: Option<bool>,
4409    group: Option<Vec<String>>,
4410    group__n: Option<Vec<String>>,
4411    group_id: Option<Vec<i32>>,
4412    group_id__n: Option<Vec<i32>>,
4413    id: Option<Vec<i32>>,
4414    id__empty: Option<bool>,
4415    id__gt: Option<Vec<i32>>,
4416    id__gte: Option<Vec<i32>>,
4417    id__lt: Option<Vec<i32>>,
4418    id__lte: Option<Vec<i32>>,
4419    id__n: Option<Vec<i32>>,
4420    limit: Option<i32>,
4421    name: Option<Vec<String>>,
4422    name__empty: Option<bool>,
4423    name__ic: Option<Vec<String>>,
4424    name__ie: Option<Vec<String>>,
4425    name__iew: Option<Vec<String>>,
4426    name__iregex: Option<Vec<String>>,
4427    name__isw: Option<Vec<String>>,
4428    name__n: Option<Vec<String>>,
4429    name__nic: Option<Vec<String>>,
4430    name__nie: Option<Vec<String>>,
4431    name__niew: Option<Vec<String>>,
4432    name__nisw: Option<Vec<String>>,
4433    name__regex: Option<Vec<String>>,
4434    object_type: Option<Vec<String>>,
4435    object_type__ic: Option<Vec<String>>,
4436    object_type__ie: Option<Vec<String>>,
4437    object_type__iew: Option<Vec<String>>,
4438    object_type__iregex: Option<Vec<String>>,
4439    object_type__isw: Option<Vec<String>>,
4440    object_type__n: Option<Vec<String>>,
4441    object_type__nic: Option<Vec<String>>,
4442    object_type__nie: Option<Vec<String>>,
4443    object_type__niew: Option<Vec<String>>,
4444    object_type__nisw: Option<Vec<String>>,
4445    object_type__regex: Option<Vec<String>>,
4446    object_type_id: Option<Vec<i32>>,
4447    object_type_id__n: Option<Vec<i32>>,
4448    object_types: Option<Vec<i32>>,
4449    object_types__n: Option<Vec<i32>>,
4450    offset: Option<i32>,
4451    ordering: Option<&str>,
4452    q: Option<&str>,
4453    start: Option<i32>,
4454    user: Option<Vec<String>>,
4455    user__n: Option<Vec<String>>,
4456    user_id: Option<Vec<i32>>,
4457    user_id__n: Option<Vec<i32>>,
4458) -> Result<crate::models::PaginatedObjectPermissionList, Error<UsersPermissionsListError>> {
4459    let local_var_configuration = configuration;
4460
4461    let local_var_client = &local_var_configuration.client;
4462
4463    let local_var_uri_str = format!(
4464        "{}/api/users/permissions/",
4465        local_var_configuration.base_path
4466    );
4467    let mut local_var_req_builder =
4468        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4469
4470    if let Some(ref local_var_str) = can_add {
4471        local_var_req_builder =
4472            local_var_req_builder.query(&[("can_add", &local_var_str.to_string())]);
4473    }
4474    if let Some(ref local_var_str) = can_change {
4475        local_var_req_builder =
4476            local_var_req_builder.query(&[("can_change", &local_var_str.to_string())]);
4477    }
4478    if let Some(ref local_var_str) = can_delete {
4479        local_var_req_builder =
4480            local_var_req_builder.query(&[("can_delete", &local_var_str.to_string())]);
4481    }
4482    if let Some(ref local_var_str) = can_view {
4483        local_var_req_builder =
4484            local_var_req_builder.query(&[("can_view", &local_var_str.to_string())]);
4485    }
4486    if let Some(ref local_var_str) = description {
4487        local_var_req_builder = match "multi" {
4488            "multi" => local_var_req_builder.query(
4489                &local_var_str
4490                    .into_iter()
4491                    .map(|p| ("description".to_owned(), p.to_string()))
4492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4493            ),
4494            _ => local_var_req_builder.query(&[(
4495                "description",
4496                &local_var_str
4497                    .into_iter()
4498                    .map(|p| p.to_string())
4499                    .collect::<Vec<String>>()
4500                    .join(",")
4501                    .to_string(),
4502            )]),
4503        };
4504    }
4505    if let Some(ref local_var_str) = description__empty {
4506        local_var_req_builder =
4507            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4508    }
4509    if let Some(ref local_var_str) = description__ic {
4510        local_var_req_builder = match "multi" {
4511            "multi" => local_var_req_builder.query(
4512                &local_var_str
4513                    .into_iter()
4514                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4516            ),
4517            _ => local_var_req_builder.query(&[(
4518                "description__ic",
4519                &local_var_str
4520                    .into_iter()
4521                    .map(|p| p.to_string())
4522                    .collect::<Vec<String>>()
4523                    .join(",")
4524                    .to_string(),
4525            )]),
4526        };
4527    }
4528    if let Some(ref local_var_str) = description__ie {
4529        local_var_req_builder = match "multi" {
4530            "multi" => local_var_req_builder.query(
4531                &local_var_str
4532                    .into_iter()
4533                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4535            ),
4536            _ => local_var_req_builder.query(&[(
4537                "description__ie",
4538                &local_var_str
4539                    .into_iter()
4540                    .map(|p| p.to_string())
4541                    .collect::<Vec<String>>()
4542                    .join(",")
4543                    .to_string(),
4544            )]),
4545        };
4546    }
4547    if let Some(ref local_var_str) = description__iew {
4548        local_var_req_builder = match "multi" {
4549            "multi" => local_var_req_builder.query(
4550                &local_var_str
4551                    .into_iter()
4552                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4554            ),
4555            _ => local_var_req_builder.query(&[(
4556                "description__iew",
4557                &local_var_str
4558                    .into_iter()
4559                    .map(|p| p.to_string())
4560                    .collect::<Vec<String>>()
4561                    .join(",")
4562                    .to_string(),
4563            )]),
4564        };
4565    }
4566    if let Some(ref local_var_str) = description__iregex {
4567        local_var_req_builder = match "multi" {
4568            "multi" => local_var_req_builder.query(
4569                &local_var_str
4570                    .into_iter()
4571                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4573            ),
4574            _ => local_var_req_builder.query(&[(
4575                "description__iregex",
4576                &local_var_str
4577                    .into_iter()
4578                    .map(|p| p.to_string())
4579                    .collect::<Vec<String>>()
4580                    .join(",")
4581                    .to_string(),
4582            )]),
4583        };
4584    }
4585    if let Some(ref local_var_str) = description__isw {
4586        local_var_req_builder = match "multi" {
4587            "multi" => local_var_req_builder.query(
4588                &local_var_str
4589                    .into_iter()
4590                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4591                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4592            ),
4593            _ => local_var_req_builder.query(&[(
4594                "description__isw",
4595                &local_var_str
4596                    .into_iter()
4597                    .map(|p| p.to_string())
4598                    .collect::<Vec<String>>()
4599                    .join(",")
4600                    .to_string(),
4601            )]),
4602        };
4603    }
4604    if let Some(ref local_var_str) = description__n {
4605        local_var_req_builder = match "multi" {
4606            "multi" => local_var_req_builder.query(
4607                &local_var_str
4608                    .into_iter()
4609                    .map(|p| ("description__n".to_owned(), p.to_string()))
4610                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4611            ),
4612            _ => local_var_req_builder.query(&[(
4613                "description__n",
4614                &local_var_str
4615                    .into_iter()
4616                    .map(|p| p.to_string())
4617                    .collect::<Vec<String>>()
4618                    .join(",")
4619                    .to_string(),
4620            )]),
4621        };
4622    }
4623    if let Some(ref local_var_str) = description__nic {
4624        local_var_req_builder = match "multi" {
4625            "multi" => local_var_req_builder.query(
4626                &local_var_str
4627                    .into_iter()
4628                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4629                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4630            ),
4631            _ => local_var_req_builder.query(&[(
4632                "description__nic",
4633                &local_var_str
4634                    .into_iter()
4635                    .map(|p| p.to_string())
4636                    .collect::<Vec<String>>()
4637                    .join(",")
4638                    .to_string(),
4639            )]),
4640        };
4641    }
4642    if let Some(ref local_var_str) = description__nie {
4643        local_var_req_builder = match "multi" {
4644            "multi" => local_var_req_builder.query(
4645                &local_var_str
4646                    .into_iter()
4647                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4648                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4649            ),
4650            _ => local_var_req_builder.query(&[(
4651                "description__nie",
4652                &local_var_str
4653                    .into_iter()
4654                    .map(|p| p.to_string())
4655                    .collect::<Vec<String>>()
4656                    .join(",")
4657                    .to_string(),
4658            )]),
4659        };
4660    }
4661    if let Some(ref local_var_str) = description__niew {
4662        local_var_req_builder = match "multi" {
4663            "multi" => local_var_req_builder.query(
4664                &local_var_str
4665                    .into_iter()
4666                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4668            ),
4669            _ => local_var_req_builder.query(&[(
4670                "description__niew",
4671                &local_var_str
4672                    .into_iter()
4673                    .map(|p| p.to_string())
4674                    .collect::<Vec<String>>()
4675                    .join(",")
4676                    .to_string(),
4677            )]),
4678        };
4679    }
4680    if let Some(ref local_var_str) = description__nisw {
4681        local_var_req_builder = match "multi" {
4682            "multi" => local_var_req_builder.query(
4683                &local_var_str
4684                    .into_iter()
4685                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4687            ),
4688            _ => local_var_req_builder.query(&[(
4689                "description__nisw",
4690                &local_var_str
4691                    .into_iter()
4692                    .map(|p| p.to_string())
4693                    .collect::<Vec<String>>()
4694                    .join(",")
4695                    .to_string(),
4696            )]),
4697        };
4698    }
4699    if let Some(ref local_var_str) = description__regex {
4700        local_var_req_builder = match "multi" {
4701            "multi" => local_var_req_builder.query(
4702                &local_var_str
4703                    .into_iter()
4704                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4706            ),
4707            _ => local_var_req_builder.query(&[(
4708                "description__regex",
4709                &local_var_str
4710                    .into_iter()
4711                    .map(|p| p.to_string())
4712                    .collect::<Vec<String>>()
4713                    .join(",")
4714                    .to_string(),
4715            )]),
4716        };
4717    }
4718    if let Some(ref local_var_str) = enabled {
4719        local_var_req_builder =
4720            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
4721    }
4722    if let Some(ref local_var_str) = group {
4723        local_var_req_builder = match "multi" {
4724            "multi" => local_var_req_builder.query(
4725                &local_var_str
4726                    .into_iter()
4727                    .map(|p| ("group".to_owned(), p.to_string()))
4728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4729            ),
4730            _ => local_var_req_builder.query(&[(
4731                "group",
4732                &local_var_str
4733                    .into_iter()
4734                    .map(|p| p.to_string())
4735                    .collect::<Vec<String>>()
4736                    .join(",")
4737                    .to_string(),
4738            )]),
4739        };
4740    }
4741    if let Some(ref local_var_str) = group__n {
4742        local_var_req_builder = match "multi" {
4743            "multi" => local_var_req_builder.query(
4744                &local_var_str
4745                    .into_iter()
4746                    .map(|p| ("group__n".to_owned(), p.to_string()))
4747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4748            ),
4749            _ => local_var_req_builder.query(&[(
4750                "group__n",
4751                &local_var_str
4752                    .into_iter()
4753                    .map(|p| p.to_string())
4754                    .collect::<Vec<String>>()
4755                    .join(",")
4756                    .to_string(),
4757            )]),
4758        };
4759    }
4760    if let Some(ref local_var_str) = group_id {
4761        local_var_req_builder = match "multi" {
4762            "multi" => local_var_req_builder.query(
4763                &local_var_str
4764                    .into_iter()
4765                    .map(|p| ("group_id".to_owned(), p.to_string()))
4766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4767            ),
4768            _ => local_var_req_builder.query(&[(
4769                "group_id",
4770                &local_var_str
4771                    .into_iter()
4772                    .map(|p| p.to_string())
4773                    .collect::<Vec<String>>()
4774                    .join(",")
4775                    .to_string(),
4776            )]),
4777        };
4778    }
4779    if let Some(ref local_var_str) = group_id__n {
4780        local_var_req_builder = match "multi" {
4781            "multi" => local_var_req_builder.query(
4782                &local_var_str
4783                    .into_iter()
4784                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
4785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4786            ),
4787            _ => local_var_req_builder.query(&[(
4788                "group_id__n",
4789                &local_var_str
4790                    .into_iter()
4791                    .map(|p| p.to_string())
4792                    .collect::<Vec<String>>()
4793                    .join(",")
4794                    .to_string(),
4795            )]),
4796        };
4797    }
4798    if let Some(ref local_var_str) = id {
4799        local_var_req_builder = match "multi" {
4800            "multi" => local_var_req_builder.query(
4801                &local_var_str
4802                    .into_iter()
4803                    .map(|p| ("id".to_owned(), p.to_string()))
4804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4805            ),
4806            _ => local_var_req_builder.query(&[(
4807                "id",
4808                &local_var_str
4809                    .into_iter()
4810                    .map(|p| p.to_string())
4811                    .collect::<Vec<String>>()
4812                    .join(",")
4813                    .to_string(),
4814            )]),
4815        };
4816    }
4817    if let Some(ref local_var_str) = id__empty {
4818        local_var_req_builder =
4819            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4820    }
4821    if let Some(ref local_var_str) = id__gt {
4822        local_var_req_builder = match "multi" {
4823            "multi" => local_var_req_builder.query(
4824                &local_var_str
4825                    .into_iter()
4826                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4828            ),
4829            _ => local_var_req_builder.query(&[(
4830                "id__gt",
4831                &local_var_str
4832                    .into_iter()
4833                    .map(|p| p.to_string())
4834                    .collect::<Vec<String>>()
4835                    .join(",")
4836                    .to_string(),
4837            )]),
4838        };
4839    }
4840    if let Some(ref local_var_str) = id__gte {
4841        local_var_req_builder = match "multi" {
4842            "multi" => local_var_req_builder.query(
4843                &local_var_str
4844                    .into_iter()
4845                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4847            ),
4848            _ => local_var_req_builder.query(&[(
4849                "id__gte",
4850                &local_var_str
4851                    .into_iter()
4852                    .map(|p| p.to_string())
4853                    .collect::<Vec<String>>()
4854                    .join(",")
4855                    .to_string(),
4856            )]),
4857        };
4858    }
4859    if let Some(ref local_var_str) = id__lt {
4860        local_var_req_builder = match "multi" {
4861            "multi" => local_var_req_builder.query(
4862                &local_var_str
4863                    .into_iter()
4864                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4866            ),
4867            _ => local_var_req_builder.query(&[(
4868                "id__lt",
4869                &local_var_str
4870                    .into_iter()
4871                    .map(|p| p.to_string())
4872                    .collect::<Vec<String>>()
4873                    .join(",")
4874                    .to_string(),
4875            )]),
4876        };
4877    }
4878    if let Some(ref local_var_str) = id__lte {
4879        local_var_req_builder = match "multi" {
4880            "multi" => local_var_req_builder.query(
4881                &local_var_str
4882                    .into_iter()
4883                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4885            ),
4886            _ => local_var_req_builder.query(&[(
4887                "id__lte",
4888                &local_var_str
4889                    .into_iter()
4890                    .map(|p| p.to_string())
4891                    .collect::<Vec<String>>()
4892                    .join(",")
4893                    .to_string(),
4894            )]),
4895        };
4896    }
4897    if let Some(ref local_var_str) = id__n {
4898        local_var_req_builder = match "multi" {
4899            "multi" => local_var_req_builder.query(
4900                &local_var_str
4901                    .into_iter()
4902                    .map(|p| ("id__n".to_owned(), p.to_string()))
4903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4904            ),
4905            _ => local_var_req_builder.query(&[(
4906                "id__n",
4907                &local_var_str
4908                    .into_iter()
4909                    .map(|p| p.to_string())
4910                    .collect::<Vec<String>>()
4911                    .join(",")
4912                    .to_string(),
4913            )]),
4914        };
4915    }
4916    if let Some(ref local_var_str) = limit {
4917        local_var_req_builder =
4918            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4919    }
4920    if let Some(ref local_var_str) = name {
4921        local_var_req_builder = match "multi" {
4922            "multi" => local_var_req_builder.query(
4923                &local_var_str
4924                    .into_iter()
4925                    .map(|p| ("name".to_owned(), p.to_string()))
4926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4927            ),
4928            _ => local_var_req_builder.query(&[(
4929                "name",
4930                &local_var_str
4931                    .into_iter()
4932                    .map(|p| p.to_string())
4933                    .collect::<Vec<String>>()
4934                    .join(",")
4935                    .to_string(),
4936            )]),
4937        };
4938    }
4939    if let Some(ref local_var_str) = name__empty {
4940        local_var_req_builder =
4941            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
4942    }
4943    if let Some(ref local_var_str) = name__ic {
4944        local_var_req_builder = match "multi" {
4945            "multi" => local_var_req_builder.query(
4946                &local_var_str
4947                    .into_iter()
4948                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4950            ),
4951            _ => local_var_req_builder.query(&[(
4952                "name__ic",
4953                &local_var_str
4954                    .into_iter()
4955                    .map(|p| p.to_string())
4956                    .collect::<Vec<String>>()
4957                    .join(",")
4958                    .to_string(),
4959            )]),
4960        };
4961    }
4962    if let Some(ref local_var_str) = name__ie {
4963        local_var_req_builder = match "multi" {
4964            "multi" => local_var_req_builder.query(
4965                &local_var_str
4966                    .into_iter()
4967                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4969            ),
4970            _ => local_var_req_builder.query(&[(
4971                "name__ie",
4972                &local_var_str
4973                    .into_iter()
4974                    .map(|p| p.to_string())
4975                    .collect::<Vec<String>>()
4976                    .join(",")
4977                    .to_string(),
4978            )]),
4979        };
4980    }
4981    if let Some(ref local_var_str) = name__iew {
4982        local_var_req_builder = match "multi" {
4983            "multi" => local_var_req_builder.query(
4984                &local_var_str
4985                    .into_iter()
4986                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4988            ),
4989            _ => local_var_req_builder.query(&[(
4990                "name__iew",
4991                &local_var_str
4992                    .into_iter()
4993                    .map(|p| p.to_string())
4994                    .collect::<Vec<String>>()
4995                    .join(",")
4996                    .to_string(),
4997            )]),
4998        };
4999    }
5000    if let Some(ref local_var_str) = name__iregex {
5001        local_var_req_builder = match "multi" {
5002            "multi" => local_var_req_builder.query(
5003                &local_var_str
5004                    .into_iter()
5005                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5007            ),
5008            _ => local_var_req_builder.query(&[(
5009                "name__iregex",
5010                &local_var_str
5011                    .into_iter()
5012                    .map(|p| p.to_string())
5013                    .collect::<Vec<String>>()
5014                    .join(",")
5015                    .to_string(),
5016            )]),
5017        };
5018    }
5019    if let Some(ref local_var_str) = name__isw {
5020        local_var_req_builder = match "multi" {
5021            "multi" => local_var_req_builder.query(
5022                &local_var_str
5023                    .into_iter()
5024                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5026            ),
5027            _ => local_var_req_builder.query(&[(
5028                "name__isw",
5029                &local_var_str
5030                    .into_iter()
5031                    .map(|p| p.to_string())
5032                    .collect::<Vec<String>>()
5033                    .join(",")
5034                    .to_string(),
5035            )]),
5036        };
5037    }
5038    if let Some(ref local_var_str) = name__n {
5039        local_var_req_builder = match "multi" {
5040            "multi" => local_var_req_builder.query(
5041                &local_var_str
5042                    .into_iter()
5043                    .map(|p| ("name__n".to_owned(), p.to_string()))
5044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5045            ),
5046            _ => local_var_req_builder.query(&[(
5047                "name__n",
5048                &local_var_str
5049                    .into_iter()
5050                    .map(|p| p.to_string())
5051                    .collect::<Vec<String>>()
5052                    .join(",")
5053                    .to_string(),
5054            )]),
5055        };
5056    }
5057    if let Some(ref local_var_str) = name__nic {
5058        local_var_req_builder = match "multi" {
5059            "multi" => local_var_req_builder.query(
5060                &local_var_str
5061                    .into_iter()
5062                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5064            ),
5065            _ => local_var_req_builder.query(&[(
5066                "name__nic",
5067                &local_var_str
5068                    .into_iter()
5069                    .map(|p| p.to_string())
5070                    .collect::<Vec<String>>()
5071                    .join(",")
5072                    .to_string(),
5073            )]),
5074        };
5075    }
5076    if let Some(ref local_var_str) = name__nie {
5077        local_var_req_builder = match "multi" {
5078            "multi" => local_var_req_builder.query(
5079                &local_var_str
5080                    .into_iter()
5081                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5083            ),
5084            _ => local_var_req_builder.query(&[(
5085                "name__nie",
5086                &local_var_str
5087                    .into_iter()
5088                    .map(|p| p.to_string())
5089                    .collect::<Vec<String>>()
5090                    .join(",")
5091                    .to_string(),
5092            )]),
5093        };
5094    }
5095    if let Some(ref local_var_str) = name__niew {
5096        local_var_req_builder = match "multi" {
5097            "multi" => local_var_req_builder.query(
5098                &local_var_str
5099                    .into_iter()
5100                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5102            ),
5103            _ => local_var_req_builder.query(&[(
5104                "name__niew",
5105                &local_var_str
5106                    .into_iter()
5107                    .map(|p| p.to_string())
5108                    .collect::<Vec<String>>()
5109                    .join(",")
5110                    .to_string(),
5111            )]),
5112        };
5113    }
5114    if let Some(ref local_var_str) = name__nisw {
5115        local_var_req_builder = match "multi" {
5116            "multi" => local_var_req_builder.query(
5117                &local_var_str
5118                    .into_iter()
5119                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5121            ),
5122            _ => local_var_req_builder.query(&[(
5123                "name__nisw",
5124                &local_var_str
5125                    .into_iter()
5126                    .map(|p| p.to_string())
5127                    .collect::<Vec<String>>()
5128                    .join(",")
5129                    .to_string(),
5130            )]),
5131        };
5132    }
5133    if let Some(ref local_var_str) = name__regex {
5134        local_var_req_builder = match "multi" {
5135            "multi" => local_var_req_builder.query(
5136                &local_var_str
5137                    .into_iter()
5138                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5140            ),
5141            _ => local_var_req_builder.query(&[(
5142                "name__regex",
5143                &local_var_str
5144                    .into_iter()
5145                    .map(|p| p.to_string())
5146                    .collect::<Vec<String>>()
5147                    .join(",")
5148                    .to_string(),
5149            )]),
5150        };
5151    }
5152    if let Some(ref local_var_str) = object_type {
5153        local_var_req_builder = match "multi" {
5154            "multi" => local_var_req_builder.query(
5155                &local_var_str
5156                    .into_iter()
5157                    .map(|p| ("object_type".to_owned(), p.to_string()))
5158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5159            ),
5160            _ => local_var_req_builder.query(&[(
5161                "object_type",
5162                &local_var_str
5163                    .into_iter()
5164                    .map(|p| p.to_string())
5165                    .collect::<Vec<String>>()
5166                    .join(",")
5167                    .to_string(),
5168            )]),
5169        };
5170    }
5171    if let Some(ref local_var_str) = object_type__ic {
5172        local_var_req_builder = match "multi" {
5173            "multi" => local_var_req_builder.query(
5174                &local_var_str
5175                    .into_iter()
5176                    .map(|p| ("object_type__ic".to_owned(), p.to_string()))
5177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5178            ),
5179            _ => local_var_req_builder.query(&[(
5180                "object_type__ic",
5181                &local_var_str
5182                    .into_iter()
5183                    .map(|p| p.to_string())
5184                    .collect::<Vec<String>>()
5185                    .join(",")
5186                    .to_string(),
5187            )]),
5188        };
5189    }
5190    if let Some(ref local_var_str) = object_type__ie {
5191        local_var_req_builder = match "multi" {
5192            "multi" => local_var_req_builder.query(
5193                &local_var_str
5194                    .into_iter()
5195                    .map(|p| ("object_type__ie".to_owned(), p.to_string()))
5196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5197            ),
5198            _ => local_var_req_builder.query(&[(
5199                "object_type__ie",
5200                &local_var_str
5201                    .into_iter()
5202                    .map(|p| p.to_string())
5203                    .collect::<Vec<String>>()
5204                    .join(",")
5205                    .to_string(),
5206            )]),
5207        };
5208    }
5209    if let Some(ref local_var_str) = object_type__iew {
5210        local_var_req_builder = match "multi" {
5211            "multi" => local_var_req_builder.query(
5212                &local_var_str
5213                    .into_iter()
5214                    .map(|p| ("object_type__iew".to_owned(), p.to_string()))
5215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5216            ),
5217            _ => local_var_req_builder.query(&[(
5218                "object_type__iew",
5219                &local_var_str
5220                    .into_iter()
5221                    .map(|p| p.to_string())
5222                    .collect::<Vec<String>>()
5223                    .join(",")
5224                    .to_string(),
5225            )]),
5226        };
5227    }
5228    if let Some(ref local_var_str) = object_type__iregex {
5229        local_var_req_builder = match "multi" {
5230            "multi" => local_var_req_builder.query(
5231                &local_var_str
5232                    .into_iter()
5233                    .map(|p| ("object_type__iregex".to_owned(), p.to_string()))
5234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5235            ),
5236            _ => local_var_req_builder.query(&[(
5237                "object_type__iregex",
5238                &local_var_str
5239                    .into_iter()
5240                    .map(|p| p.to_string())
5241                    .collect::<Vec<String>>()
5242                    .join(",")
5243                    .to_string(),
5244            )]),
5245        };
5246    }
5247    if let Some(ref local_var_str) = object_type__isw {
5248        local_var_req_builder = match "multi" {
5249            "multi" => local_var_req_builder.query(
5250                &local_var_str
5251                    .into_iter()
5252                    .map(|p| ("object_type__isw".to_owned(), p.to_string()))
5253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5254            ),
5255            _ => local_var_req_builder.query(&[(
5256                "object_type__isw",
5257                &local_var_str
5258                    .into_iter()
5259                    .map(|p| p.to_string())
5260                    .collect::<Vec<String>>()
5261                    .join(",")
5262                    .to_string(),
5263            )]),
5264        };
5265    }
5266    if let Some(ref local_var_str) = object_type__n {
5267        local_var_req_builder = match "multi" {
5268            "multi" => local_var_req_builder.query(
5269                &local_var_str
5270                    .into_iter()
5271                    .map(|p| ("object_type__n".to_owned(), p.to_string()))
5272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5273            ),
5274            _ => local_var_req_builder.query(&[(
5275                "object_type__n",
5276                &local_var_str
5277                    .into_iter()
5278                    .map(|p| p.to_string())
5279                    .collect::<Vec<String>>()
5280                    .join(",")
5281                    .to_string(),
5282            )]),
5283        };
5284    }
5285    if let Some(ref local_var_str) = object_type__nic {
5286        local_var_req_builder = match "multi" {
5287            "multi" => local_var_req_builder.query(
5288                &local_var_str
5289                    .into_iter()
5290                    .map(|p| ("object_type__nic".to_owned(), p.to_string()))
5291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5292            ),
5293            _ => local_var_req_builder.query(&[(
5294                "object_type__nic",
5295                &local_var_str
5296                    .into_iter()
5297                    .map(|p| p.to_string())
5298                    .collect::<Vec<String>>()
5299                    .join(",")
5300                    .to_string(),
5301            )]),
5302        };
5303    }
5304    if let Some(ref local_var_str) = object_type__nie {
5305        local_var_req_builder = match "multi" {
5306            "multi" => local_var_req_builder.query(
5307                &local_var_str
5308                    .into_iter()
5309                    .map(|p| ("object_type__nie".to_owned(), p.to_string()))
5310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5311            ),
5312            _ => local_var_req_builder.query(&[(
5313                "object_type__nie",
5314                &local_var_str
5315                    .into_iter()
5316                    .map(|p| p.to_string())
5317                    .collect::<Vec<String>>()
5318                    .join(",")
5319                    .to_string(),
5320            )]),
5321        };
5322    }
5323    if let Some(ref local_var_str) = object_type__niew {
5324        local_var_req_builder = match "multi" {
5325            "multi" => local_var_req_builder.query(
5326                &local_var_str
5327                    .into_iter()
5328                    .map(|p| ("object_type__niew".to_owned(), p.to_string()))
5329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5330            ),
5331            _ => local_var_req_builder.query(&[(
5332                "object_type__niew",
5333                &local_var_str
5334                    .into_iter()
5335                    .map(|p| p.to_string())
5336                    .collect::<Vec<String>>()
5337                    .join(",")
5338                    .to_string(),
5339            )]),
5340        };
5341    }
5342    if let Some(ref local_var_str) = object_type__nisw {
5343        local_var_req_builder = match "multi" {
5344            "multi" => local_var_req_builder.query(
5345                &local_var_str
5346                    .into_iter()
5347                    .map(|p| ("object_type__nisw".to_owned(), p.to_string()))
5348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5349            ),
5350            _ => local_var_req_builder.query(&[(
5351                "object_type__nisw",
5352                &local_var_str
5353                    .into_iter()
5354                    .map(|p| p.to_string())
5355                    .collect::<Vec<String>>()
5356                    .join(",")
5357                    .to_string(),
5358            )]),
5359        };
5360    }
5361    if let Some(ref local_var_str) = object_type__regex {
5362        local_var_req_builder = match "multi" {
5363            "multi" => local_var_req_builder.query(
5364                &local_var_str
5365                    .into_iter()
5366                    .map(|p| ("object_type__regex".to_owned(), p.to_string()))
5367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5368            ),
5369            _ => local_var_req_builder.query(&[(
5370                "object_type__regex",
5371                &local_var_str
5372                    .into_iter()
5373                    .map(|p| p.to_string())
5374                    .collect::<Vec<String>>()
5375                    .join(",")
5376                    .to_string(),
5377            )]),
5378        };
5379    }
5380    if let Some(ref local_var_str) = object_type_id {
5381        local_var_req_builder = match "multi" {
5382            "multi" => local_var_req_builder.query(
5383                &local_var_str
5384                    .into_iter()
5385                    .map(|p| ("object_type_id".to_owned(), p.to_string()))
5386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5387            ),
5388            _ => local_var_req_builder.query(&[(
5389                "object_type_id",
5390                &local_var_str
5391                    .into_iter()
5392                    .map(|p| p.to_string())
5393                    .collect::<Vec<String>>()
5394                    .join(",")
5395                    .to_string(),
5396            )]),
5397        };
5398    }
5399    if let Some(ref local_var_str) = object_type_id__n {
5400        local_var_req_builder = match "multi" {
5401            "multi" => local_var_req_builder.query(
5402                &local_var_str
5403                    .into_iter()
5404                    .map(|p| ("object_type_id__n".to_owned(), p.to_string()))
5405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5406            ),
5407            _ => local_var_req_builder.query(&[(
5408                "object_type_id__n",
5409                &local_var_str
5410                    .into_iter()
5411                    .map(|p| p.to_string())
5412                    .collect::<Vec<String>>()
5413                    .join(",")
5414                    .to_string(),
5415            )]),
5416        };
5417    }
5418    if let Some(ref local_var_str) = object_types {
5419        local_var_req_builder = match "multi" {
5420            "multi" => local_var_req_builder.query(
5421                &local_var_str
5422                    .into_iter()
5423                    .map(|p| ("object_types".to_owned(), p.to_string()))
5424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5425            ),
5426            _ => local_var_req_builder.query(&[(
5427                "object_types",
5428                &local_var_str
5429                    .into_iter()
5430                    .map(|p| p.to_string())
5431                    .collect::<Vec<String>>()
5432                    .join(",")
5433                    .to_string(),
5434            )]),
5435        };
5436    }
5437    if let Some(ref local_var_str) = object_types__n {
5438        local_var_req_builder = match "multi" {
5439            "multi" => local_var_req_builder.query(
5440                &local_var_str
5441                    .into_iter()
5442                    .map(|p| ("object_types__n".to_owned(), p.to_string()))
5443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5444            ),
5445            _ => local_var_req_builder.query(&[(
5446                "object_types__n",
5447                &local_var_str
5448                    .into_iter()
5449                    .map(|p| p.to_string())
5450                    .collect::<Vec<String>>()
5451                    .join(",")
5452                    .to_string(),
5453            )]),
5454        };
5455    }
5456    if let Some(ref local_var_str) = offset {
5457        local_var_req_builder =
5458            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5459    }
5460    if let Some(ref local_var_str) = ordering {
5461        local_var_req_builder =
5462            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5463    }
5464    if let Some(ref local_var_str) = q {
5465        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5466    }
5467    if let Some(ref local_var_str) = start {
5468        local_var_req_builder =
5469            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
5470    }
5471    if let Some(ref local_var_str) = user {
5472        local_var_req_builder = match "multi" {
5473            "multi" => local_var_req_builder.query(
5474                &local_var_str
5475                    .into_iter()
5476                    .map(|p| ("user".to_owned(), p.to_string()))
5477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5478            ),
5479            _ => local_var_req_builder.query(&[(
5480                "user",
5481                &local_var_str
5482                    .into_iter()
5483                    .map(|p| p.to_string())
5484                    .collect::<Vec<String>>()
5485                    .join(",")
5486                    .to_string(),
5487            )]),
5488        };
5489    }
5490    if let Some(ref local_var_str) = user__n {
5491        local_var_req_builder = match "multi" {
5492            "multi" => local_var_req_builder.query(
5493                &local_var_str
5494                    .into_iter()
5495                    .map(|p| ("user__n".to_owned(), p.to_string()))
5496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5497            ),
5498            _ => local_var_req_builder.query(&[(
5499                "user__n",
5500                &local_var_str
5501                    .into_iter()
5502                    .map(|p| p.to_string())
5503                    .collect::<Vec<String>>()
5504                    .join(",")
5505                    .to_string(),
5506            )]),
5507        };
5508    }
5509    if let Some(ref local_var_str) = user_id {
5510        local_var_req_builder = match "multi" {
5511            "multi" => local_var_req_builder.query(
5512                &local_var_str
5513                    .into_iter()
5514                    .map(|p| ("user_id".to_owned(), p.to_string()))
5515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5516            ),
5517            _ => local_var_req_builder.query(&[(
5518                "user_id",
5519                &local_var_str
5520                    .into_iter()
5521                    .map(|p| p.to_string())
5522                    .collect::<Vec<String>>()
5523                    .join(",")
5524                    .to_string(),
5525            )]),
5526        };
5527    }
5528    if let Some(ref local_var_str) = user_id__n {
5529        local_var_req_builder = match "multi" {
5530            "multi" => local_var_req_builder.query(
5531                &local_var_str
5532                    .into_iter()
5533                    .map(|p| ("user_id__n".to_owned(), p.to_string()))
5534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5535            ),
5536            _ => local_var_req_builder.query(&[(
5537                "user_id__n",
5538                &local_var_str
5539                    .into_iter()
5540                    .map(|p| p.to_string())
5541                    .collect::<Vec<String>>()
5542                    .join(",")
5543                    .to_string(),
5544            )]),
5545        };
5546    }
5547    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5548        local_var_req_builder =
5549            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5550    }
5551    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5552        let local_var_key = local_var_apikey.key.clone();
5553        let local_var_value = match local_var_apikey.prefix {
5554            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5555            None => local_var_key,
5556        };
5557        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5558    };
5559
5560    let local_var_req = local_var_req_builder.build()?;
5561    let local_var_resp = local_var_client.execute(local_var_req).await?;
5562
5563    let local_var_status = local_var_resp.status();
5564    let local_var_content = local_var_resp.text().await?;
5565
5566    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5567        serde_json::from_str(&local_var_content).map_err(Error::from)
5568    } else {
5569        let local_var_entity: Option<UsersPermissionsListError> =
5570            serde_json::from_str(&local_var_content).ok();
5571        let local_var_error = ResponseContent {
5572            status: local_var_status,
5573            content: local_var_content,
5574            entity: local_var_entity,
5575        };
5576        Err(Error::ResponseError(local_var_error))
5577    }
5578}
5579
5580/// Patch a permission object.
5581pub async fn users_permissions_partial_update(
5582    configuration: &configuration::Configuration,
5583    id: i32,
5584    patched_object_permission_request: Option<crate::models::PatchedObjectPermissionRequest>,
5585) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsPartialUpdateError>> {
5586    let local_var_configuration = configuration;
5587
5588    let local_var_client = &local_var_configuration.client;
5589
5590    let local_var_uri_str = format!(
5591        "{}/api/users/permissions/{id}/",
5592        local_var_configuration.base_path,
5593        id = id
5594    );
5595    let mut local_var_req_builder =
5596        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5597
5598    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5599        local_var_req_builder =
5600            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5601    }
5602    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5603        let local_var_key = local_var_apikey.key.clone();
5604        let local_var_value = match local_var_apikey.prefix {
5605            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5606            None => local_var_key,
5607        };
5608        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5609    };
5610    local_var_req_builder = local_var_req_builder.json(&patched_object_permission_request);
5611
5612    let local_var_req = local_var_req_builder.build()?;
5613    let local_var_resp = local_var_client.execute(local_var_req).await?;
5614
5615    let local_var_status = local_var_resp.status();
5616    let local_var_content = local_var_resp.text().await?;
5617
5618    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5619        serde_json::from_str(&local_var_content).map_err(Error::from)
5620    } else {
5621        let local_var_entity: Option<UsersPermissionsPartialUpdateError> =
5622            serde_json::from_str(&local_var_content).ok();
5623        let local_var_error = ResponseContent {
5624            status: local_var_status,
5625            content: local_var_content,
5626            entity: local_var_entity,
5627        };
5628        Err(Error::ResponseError(local_var_error))
5629    }
5630}
5631
5632/// Get a permission object.
5633pub async fn users_permissions_retrieve(
5634    configuration: &configuration::Configuration,
5635    id: i32,
5636) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsRetrieveError>> {
5637    let local_var_configuration = configuration;
5638
5639    let local_var_client = &local_var_configuration.client;
5640
5641    let local_var_uri_str = format!(
5642        "{}/api/users/permissions/{id}/",
5643        local_var_configuration.base_path,
5644        id = id
5645    );
5646    let mut local_var_req_builder =
5647        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5648
5649    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5650        local_var_req_builder =
5651            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5652    }
5653    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5654        let local_var_key = local_var_apikey.key.clone();
5655        let local_var_value = match local_var_apikey.prefix {
5656            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5657            None => local_var_key,
5658        };
5659        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5660    };
5661
5662    let local_var_req = local_var_req_builder.build()?;
5663    let local_var_resp = local_var_client.execute(local_var_req).await?;
5664
5665    let local_var_status = local_var_resp.status();
5666    let local_var_content = local_var_resp.text().await?;
5667
5668    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5669        serde_json::from_str(&local_var_content).map_err(Error::from)
5670    } else {
5671        let local_var_entity: Option<UsersPermissionsRetrieveError> =
5672            serde_json::from_str(&local_var_content).ok();
5673        let local_var_error = ResponseContent {
5674            status: local_var_status,
5675            content: local_var_content,
5676            entity: local_var_entity,
5677        };
5678        Err(Error::ResponseError(local_var_error))
5679    }
5680}
5681
5682/// Put a permission object.
5683pub async fn users_permissions_update(
5684    configuration: &configuration::Configuration,
5685    id: i32,
5686    object_permission_request: crate::models::ObjectPermissionRequest,
5687) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsUpdateError>> {
5688    let local_var_configuration = configuration;
5689
5690    let local_var_client = &local_var_configuration.client;
5691
5692    let local_var_uri_str = format!(
5693        "{}/api/users/permissions/{id}/",
5694        local_var_configuration.base_path,
5695        id = id
5696    );
5697    let mut local_var_req_builder =
5698        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5699
5700    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5701        local_var_req_builder =
5702            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5703    }
5704    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5705        let local_var_key = local_var_apikey.key.clone();
5706        let local_var_value = match local_var_apikey.prefix {
5707            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5708            None => local_var_key,
5709        };
5710        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5711    };
5712    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
5713
5714    let local_var_req = local_var_req_builder.build()?;
5715    let local_var_resp = local_var_client.execute(local_var_req).await?;
5716
5717    let local_var_status = local_var_resp.status();
5718    let local_var_content = local_var_resp.text().await?;
5719
5720    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5721        serde_json::from_str(&local_var_content).map_err(Error::from)
5722    } else {
5723        let local_var_entity: Option<UsersPermissionsUpdateError> =
5724            serde_json::from_str(&local_var_content).ok();
5725        let local_var_error = ResponseContent {
5726            status: local_var_status,
5727            content: local_var_content,
5728            entity: local_var_entity,
5729        };
5730        Err(Error::ResponseError(local_var_error))
5731    }
5732}
5733
5734/// Delete a list of token objects.
5735pub async fn users_tokens_bulk_destroy(
5736    configuration: &configuration::Configuration,
5737    token_request: Vec<crate::models::TokenRequest>,
5738) -> Result<(), Error<UsersTokensBulkDestroyError>> {
5739    let local_var_configuration = configuration;
5740
5741    let local_var_client = &local_var_configuration.client;
5742
5743    let local_var_uri_str = format!("{}/api/users/tokens/", local_var_configuration.base_path);
5744    let mut local_var_req_builder =
5745        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5746
5747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5748        local_var_req_builder =
5749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5750    }
5751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5752        let local_var_key = local_var_apikey.key.clone();
5753        let local_var_value = match local_var_apikey.prefix {
5754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5755            None => local_var_key,
5756        };
5757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5758    };
5759    local_var_req_builder = local_var_req_builder.json(&token_request);
5760
5761    let local_var_req = local_var_req_builder.build()?;
5762    let local_var_resp = local_var_client.execute(local_var_req).await?;
5763
5764    let local_var_status = local_var_resp.status();
5765    let local_var_content = local_var_resp.text().await?;
5766
5767    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5768        Ok(())
5769    } else {
5770        let local_var_entity: Option<UsersTokensBulkDestroyError> =
5771            serde_json::from_str(&local_var_content).ok();
5772        let local_var_error = ResponseContent {
5773            status: local_var_status,
5774            content: local_var_content,
5775            entity: local_var_entity,
5776        };
5777        Err(Error::ResponseError(local_var_error))
5778    }
5779}
5780
5781/// Patch a list of token objects.
5782pub async fn users_tokens_bulk_partial_update(
5783    configuration: &configuration::Configuration,
5784    token_request: Vec<crate::models::TokenRequest>,
5785) -> Result<Vec<crate::models::Token>, Error<UsersTokensBulkPartialUpdateError>> {
5786    let local_var_configuration = configuration;
5787
5788    let local_var_client = &local_var_configuration.client;
5789
5790    let local_var_uri_str = format!("{}/api/users/tokens/", local_var_configuration.base_path);
5791    let mut local_var_req_builder =
5792        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5793
5794    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5795        local_var_req_builder =
5796            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5797    }
5798    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5799        let local_var_key = local_var_apikey.key.clone();
5800        let local_var_value = match local_var_apikey.prefix {
5801            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5802            None => local_var_key,
5803        };
5804        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5805    };
5806    local_var_req_builder = local_var_req_builder.json(&token_request);
5807
5808    let local_var_req = local_var_req_builder.build()?;
5809    let local_var_resp = local_var_client.execute(local_var_req).await?;
5810
5811    let local_var_status = local_var_resp.status();
5812    let local_var_content = local_var_resp.text().await?;
5813
5814    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5815        serde_json::from_str(&local_var_content).map_err(Error::from)
5816    } else {
5817        let local_var_entity: Option<UsersTokensBulkPartialUpdateError> =
5818            serde_json::from_str(&local_var_content).ok();
5819        let local_var_error = ResponseContent {
5820            status: local_var_status,
5821            content: local_var_content,
5822            entity: local_var_entity,
5823        };
5824        Err(Error::ResponseError(local_var_error))
5825    }
5826}
5827
5828/// Put a list of token objects.
5829pub async fn users_tokens_bulk_update(
5830    configuration: &configuration::Configuration,
5831    token_request: Vec<crate::models::TokenRequest>,
5832) -> Result<Vec<crate::models::Token>, Error<UsersTokensBulkUpdateError>> {
5833    let local_var_configuration = configuration;
5834
5835    let local_var_client = &local_var_configuration.client;
5836
5837    let local_var_uri_str = format!("{}/api/users/tokens/", local_var_configuration.base_path);
5838    let mut local_var_req_builder =
5839        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5840
5841    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5842        local_var_req_builder =
5843            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5844    }
5845    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5846        let local_var_key = local_var_apikey.key.clone();
5847        let local_var_value = match local_var_apikey.prefix {
5848            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5849            None => local_var_key,
5850        };
5851        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5852    };
5853    local_var_req_builder = local_var_req_builder.json(&token_request);
5854
5855    let local_var_req = local_var_req_builder.build()?;
5856    let local_var_resp = local_var_client.execute(local_var_req).await?;
5857
5858    let local_var_status = local_var_resp.status();
5859    let local_var_content = local_var_resp.text().await?;
5860
5861    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5862        serde_json::from_str(&local_var_content).map_err(Error::from)
5863    } else {
5864        let local_var_entity: Option<UsersTokensBulkUpdateError> =
5865            serde_json::from_str(&local_var_content).ok();
5866        let local_var_error = ResponseContent {
5867            status: local_var_status,
5868            content: local_var_content,
5869            entity: local_var_entity,
5870        };
5871        Err(Error::ResponseError(local_var_error))
5872    }
5873}
5874
5875/// Post a list of token objects.
5876pub async fn users_tokens_create(
5877    configuration: &configuration::Configuration,
5878    users_tokens_create_request: crate::models::UsersTokensCreateRequest,
5879) -> Result<crate::models::Token, Error<UsersTokensCreateError>> {
5880    let local_var_configuration = configuration;
5881
5882    let local_var_client = &local_var_configuration.client;
5883
5884    let local_var_uri_str = format!("{}/api/users/tokens/", local_var_configuration.base_path);
5885    let mut local_var_req_builder =
5886        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5887
5888    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5889        local_var_req_builder =
5890            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5891    }
5892    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5893        let local_var_key = local_var_apikey.key.clone();
5894        let local_var_value = match local_var_apikey.prefix {
5895            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5896            None => local_var_key,
5897        };
5898        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5899    };
5900    local_var_req_builder = local_var_req_builder.json(&users_tokens_create_request);
5901
5902    let local_var_req = local_var_req_builder.build()?;
5903    let local_var_resp = local_var_client.execute(local_var_req).await?;
5904
5905    let local_var_status = local_var_resp.status();
5906    let local_var_content = local_var_resp.text().await?;
5907
5908    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5909        serde_json::from_str(&local_var_content).map_err(Error::from)
5910    } else {
5911        let local_var_entity: Option<UsersTokensCreateError> =
5912            serde_json::from_str(&local_var_content).ok();
5913        let local_var_error = ResponseContent {
5914            status: local_var_status,
5915            content: local_var_content,
5916            entity: local_var_entity,
5917        };
5918        Err(Error::ResponseError(local_var_error))
5919    }
5920}
5921
5922/// Delete a token object.
5923pub async fn users_tokens_destroy(
5924    configuration: &configuration::Configuration,
5925    id: i32,
5926) -> Result<(), Error<UsersTokensDestroyError>> {
5927    let local_var_configuration = configuration;
5928
5929    let local_var_client = &local_var_configuration.client;
5930
5931    let local_var_uri_str = format!(
5932        "{}/api/users/tokens/{id}/",
5933        local_var_configuration.base_path,
5934        id = id
5935    );
5936    let mut local_var_req_builder =
5937        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5938
5939    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5940        local_var_req_builder =
5941            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5942    }
5943    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5944        let local_var_key = local_var_apikey.key.clone();
5945        let local_var_value = match local_var_apikey.prefix {
5946            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5947            None => local_var_key,
5948        };
5949        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5950    };
5951
5952    let local_var_req = local_var_req_builder.build()?;
5953    let local_var_resp = local_var_client.execute(local_var_req).await?;
5954
5955    let local_var_status = local_var_resp.status();
5956    let local_var_content = local_var_resp.text().await?;
5957
5958    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5959        Ok(())
5960    } else {
5961        let local_var_entity: Option<UsersTokensDestroyError> =
5962            serde_json::from_str(&local_var_content).ok();
5963        let local_var_error = ResponseContent {
5964            status: local_var_status,
5965            content: local_var_content,
5966            entity: local_var_entity,
5967        };
5968        Err(Error::ResponseError(local_var_error))
5969    }
5970}
5971
5972/// Get a list of token objects.
5973pub async fn users_tokens_list(
5974    configuration: &configuration::Configuration,
5975    created: Option<String>,
5976    created__gte: Option<String>,
5977    created__lte: Option<String>,
5978    description: Option<Vec<String>>,
5979    description__empty: Option<bool>,
5980    description__ic: Option<Vec<String>>,
5981    description__ie: Option<Vec<String>>,
5982    description__iew: Option<Vec<String>>,
5983    description__iregex: Option<Vec<String>>,
5984    description__isw: Option<Vec<String>>,
5985    description__n: Option<Vec<String>>,
5986    description__nic: Option<Vec<String>>,
5987    description__nie: Option<Vec<String>>,
5988    description__niew: Option<Vec<String>>,
5989    description__nisw: Option<Vec<String>>,
5990    description__regex: Option<Vec<String>>,
5991    enabled: Option<bool>,
5992    expires: Option<String>,
5993    expires__gte: Option<String>,
5994    expires__lte: Option<String>,
5995    id: Option<Vec<i32>>,
5996    id__empty: Option<bool>,
5997    id__gt: Option<Vec<i32>>,
5998    id__gte: Option<Vec<i32>>,
5999    id__lt: Option<Vec<i32>>,
6000    id__lte: Option<Vec<i32>>,
6001    id__n: Option<Vec<i32>>,
6002    key: Option<Vec<String>>,
6003    key__empty: Option<bool>,
6004    key__ic: Option<Vec<String>>,
6005    key__ie: Option<Vec<String>>,
6006    key__iew: Option<Vec<String>>,
6007    key__iregex: Option<Vec<String>>,
6008    key__isw: Option<Vec<String>>,
6009    key__n: Option<Vec<String>>,
6010    key__nic: Option<Vec<String>>,
6011    key__nie: Option<Vec<String>>,
6012    key__niew: Option<Vec<String>>,
6013    key__nisw: Option<Vec<String>>,
6014    key__regex: Option<Vec<String>>,
6015    last_used: Option<String>,
6016    last_used__gte: Option<String>,
6017    last_used__lte: Option<String>,
6018    limit: Option<i32>,
6019    offset: Option<i32>,
6020    ordering: Option<&str>,
6021    pepper_id: Option<Vec<i32>>,
6022    pepper_id__empty: Option<bool>,
6023    pepper_id__gt: Option<Vec<i32>>,
6024    pepper_id__gte: Option<Vec<i32>>,
6025    pepper_id__lt: Option<Vec<i32>>,
6026    pepper_id__lte: Option<Vec<i32>>,
6027    pepper_id__n: Option<Vec<i32>>,
6028    q: Option<&str>,
6029    start: Option<i32>,
6030    user: Option<Vec<String>>,
6031    user__n: Option<Vec<String>>,
6032    user_id: Option<Vec<i32>>,
6033    user_id__n: Option<Vec<i32>>,
6034    version: Option<i32>,
6035    version__ic: Option<Vec<i32>>,
6036    version__ie: Option<Vec<i32>>,
6037    version__iew: Option<Vec<i32>>,
6038    version__iregex: Option<Vec<i32>>,
6039    version__isw: Option<Vec<i32>>,
6040    version__n: Option<i32>,
6041    version__nic: Option<Vec<i32>>,
6042    version__nie: Option<Vec<i32>>,
6043    version__niew: Option<Vec<i32>>,
6044    version__nisw: Option<Vec<i32>>,
6045    version__regex: Option<Vec<i32>>,
6046    write_enabled: Option<bool>,
6047) -> Result<crate::models::PaginatedTokenList, Error<UsersTokensListError>> {
6048    let local_var_configuration = configuration;
6049
6050    let local_var_client = &local_var_configuration.client;
6051
6052    let local_var_uri_str = format!("{}/api/users/tokens/", local_var_configuration.base_path);
6053    let mut local_var_req_builder =
6054        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6055
6056    if let Some(ref local_var_str) = created {
6057        local_var_req_builder =
6058            local_var_req_builder.query(&[("created", &local_var_str.to_string())]);
6059    }
6060    if let Some(ref local_var_str) = created__gte {
6061        local_var_req_builder =
6062            local_var_req_builder.query(&[("created__gte", &local_var_str.to_string())]);
6063    }
6064    if let Some(ref local_var_str) = created__lte {
6065        local_var_req_builder =
6066            local_var_req_builder.query(&[("created__lte", &local_var_str.to_string())]);
6067    }
6068    if let Some(ref local_var_str) = description {
6069        local_var_req_builder = match "multi" {
6070            "multi" => local_var_req_builder.query(
6071                &local_var_str
6072                    .into_iter()
6073                    .map(|p| ("description".to_owned(), p.to_string()))
6074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6075            ),
6076            _ => local_var_req_builder.query(&[(
6077                "description",
6078                &local_var_str
6079                    .into_iter()
6080                    .map(|p| p.to_string())
6081                    .collect::<Vec<String>>()
6082                    .join(",")
6083                    .to_string(),
6084            )]),
6085        };
6086    }
6087    if let Some(ref local_var_str) = description__empty {
6088        local_var_req_builder =
6089            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6090    }
6091    if let Some(ref local_var_str) = description__ic {
6092        local_var_req_builder = match "multi" {
6093            "multi" => local_var_req_builder.query(
6094                &local_var_str
6095                    .into_iter()
6096                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6098            ),
6099            _ => local_var_req_builder.query(&[(
6100                "description__ic",
6101                &local_var_str
6102                    .into_iter()
6103                    .map(|p| p.to_string())
6104                    .collect::<Vec<String>>()
6105                    .join(",")
6106                    .to_string(),
6107            )]),
6108        };
6109    }
6110    if let Some(ref local_var_str) = description__ie {
6111        local_var_req_builder = match "multi" {
6112            "multi" => local_var_req_builder.query(
6113                &local_var_str
6114                    .into_iter()
6115                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6117            ),
6118            _ => local_var_req_builder.query(&[(
6119                "description__ie",
6120                &local_var_str
6121                    .into_iter()
6122                    .map(|p| p.to_string())
6123                    .collect::<Vec<String>>()
6124                    .join(",")
6125                    .to_string(),
6126            )]),
6127        };
6128    }
6129    if let Some(ref local_var_str) = description__iew {
6130        local_var_req_builder = match "multi" {
6131            "multi" => local_var_req_builder.query(
6132                &local_var_str
6133                    .into_iter()
6134                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6136            ),
6137            _ => local_var_req_builder.query(&[(
6138                "description__iew",
6139                &local_var_str
6140                    .into_iter()
6141                    .map(|p| p.to_string())
6142                    .collect::<Vec<String>>()
6143                    .join(",")
6144                    .to_string(),
6145            )]),
6146        };
6147    }
6148    if let Some(ref local_var_str) = description__iregex {
6149        local_var_req_builder = match "multi" {
6150            "multi" => local_var_req_builder.query(
6151                &local_var_str
6152                    .into_iter()
6153                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6155            ),
6156            _ => local_var_req_builder.query(&[(
6157                "description__iregex",
6158                &local_var_str
6159                    .into_iter()
6160                    .map(|p| p.to_string())
6161                    .collect::<Vec<String>>()
6162                    .join(",")
6163                    .to_string(),
6164            )]),
6165        };
6166    }
6167    if let Some(ref local_var_str) = description__isw {
6168        local_var_req_builder = match "multi" {
6169            "multi" => local_var_req_builder.query(
6170                &local_var_str
6171                    .into_iter()
6172                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6174            ),
6175            _ => local_var_req_builder.query(&[(
6176                "description__isw",
6177                &local_var_str
6178                    .into_iter()
6179                    .map(|p| p.to_string())
6180                    .collect::<Vec<String>>()
6181                    .join(",")
6182                    .to_string(),
6183            )]),
6184        };
6185    }
6186    if let Some(ref local_var_str) = description__n {
6187        local_var_req_builder = match "multi" {
6188            "multi" => local_var_req_builder.query(
6189                &local_var_str
6190                    .into_iter()
6191                    .map(|p| ("description__n".to_owned(), p.to_string()))
6192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6193            ),
6194            _ => local_var_req_builder.query(&[(
6195                "description__n",
6196                &local_var_str
6197                    .into_iter()
6198                    .map(|p| p.to_string())
6199                    .collect::<Vec<String>>()
6200                    .join(",")
6201                    .to_string(),
6202            )]),
6203        };
6204    }
6205    if let Some(ref local_var_str) = description__nic {
6206        local_var_req_builder = match "multi" {
6207            "multi" => local_var_req_builder.query(
6208                &local_var_str
6209                    .into_iter()
6210                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6212            ),
6213            _ => local_var_req_builder.query(&[(
6214                "description__nic",
6215                &local_var_str
6216                    .into_iter()
6217                    .map(|p| p.to_string())
6218                    .collect::<Vec<String>>()
6219                    .join(",")
6220                    .to_string(),
6221            )]),
6222        };
6223    }
6224    if let Some(ref local_var_str) = description__nie {
6225        local_var_req_builder = match "multi" {
6226            "multi" => local_var_req_builder.query(
6227                &local_var_str
6228                    .into_iter()
6229                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6231            ),
6232            _ => local_var_req_builder.query(&[(
6233                "description__nie",
6234                &local_var_str
6235                    .into_iter()
6236                    .map(|p| p.to_string())
6237                    .collect::<Vec<String>>()
6238                    .join(",")
6239                    .to_string(),
6240            )]),
6241        };
6242    }
6243    if let Some(ref local_var_str) = description__niew {
6244        local_var_req_builder = match "multi" {
6245            "multi" => local_var_req_builder.query(
6246                &local_var_str
6247                    .into_iter()
6248                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6250            ),
6251            _ => local_var_req_builder.query(&[(
6252                "description__niew",
6253                &local_var_str
6254                    .into_iter()
6255                    .map(|p| p.to_string())
6256                    .collect::<Vec<String>>()
6257                    .join(",")
6258                    .to_string(),
6259            )]),
6260        };
6261    }
6262    if let Some(ref local_var_str) = description__nisw {
6263        local_var_req_builder = match "multi" {
6264            "multi" => local_var_req_builder.query(
6265                &local_var_str
6266                    .into_iter()
6267                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6269            ),
6270            _ => local_var_req_builder.query(&[(
6271                "description__nisw",
6272                &local_var_str
6273                    .into_iter()
6274                    .map(|p| p.to_string())
6275                    .collect::<Vec<String>>()
6276                    .join(",")
6277                    .to_string(),
6278            )]),
6279        };
6280    }
6281    if let Some(ref local_var_str) = description__regex {
6282        local_var_req_builder = match "multi" {
6283            "multi" => local_var_req_builder.query(
6284                &local_var_str
6285                    .into_iter()
6286                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6288            ),
6289            _ => local_var_req_builder.query(&[(
6290                "description__regex",
6291                &local_var_str
6292                    .into_iter()
6293                    .map(|p| p.to_string())
6294                    .collect::<Vec<String>>()
6295                    .join(",")
6296                    .to_string(),
6297            )]),
6298        };
6299    }
6300    if let Some(ref local_var_str) = enabled {
6301        local_var_req_builder =
6302            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
6303    }
6304    if let Some(ref local_var_str) = expires {
6305        local_var_req_builder =
6306            local_var_req_builder.query(&[("expires", &local_var_str.to_string())]);
6307    }
6308    if let Some(ref local_var_str) = expires__gte {
6309        local_var_req_builder =
6310            local_var_req_builder.query(&[("expires__gte", &local_var_str.to_string())]);
6311    }
6312    if let Some(ref local_var_str) = expires__lte {
6313        local_var_req_builder =
6314            local_var_req_builder.query(&[("expires__lte", &local_var_str.to_string())]);
6315    }
6316    if let Some(ref local_var_str) = id {
6317        local_var_req_builder = match "multi" {
6318            "multi" => local_var_req_builder.query(
6319                &local_var_str
6320                    .into_iter()
6321                    .map(|p| ("id".to_owned(), p.to_string()))
6322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6323            ),
6324            _ => local_var_req_builder.query(&[(
6325                "id",
6326                &local_var_str
6327                    .into_iter()
6328                    .map(|p| p.to_string())
6329                    .collect::<Vec<String>>()
6330                    .join(",")
6331                    .to_string(),
6332            )]),
6333        };
6334    }
6335    if let Some(ref local_var_str) = id__empty {
6336        local_var_req_builder =
6337            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6338    }
6339    if let Some(ref local_var_str) = id__gt {
6340        local_var_req_builder = match "multi" {
6341            "multi" => local_var_req_builder.query(
6342                &local_var_str
6343                    .into_iter()
6344                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6346            ),
6347            _ => local_var_req_builder.query(&[(
6348                "id__gt",
6349                &local_var_str
6350                    .into_iter()
6351                    .map(|p| p.to_string())
6352                    .collect::<Vec<String>>()
6353                    .join(",")
6354                    .to_string(),
6355            )]),
6356        };
6357    }
6358    if let Some(ref local_var_str) = id__gte {
6359        local_var_req_builder = match "multi" {
6360            "multi" => local_var_req_builder.query(
6361                &local_var_str
6362                    .into_iter()
6363                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6365            ),
6366            _ => local_var_req_builder.query(&[(
6367                "id__gte",
6368                &local_var_str
6369                    .into_iter()
6370                    .map(|p| p.to_string())
6371                    .collect::<Vec<String>>()
6372                    .join(",")
6373                    .to_string(),
6374            )]),
6375        };
6376    }
6377    if let Some(ref local_var_str) = id__lt {
6378        local_var_req_builder = match "multi" {
6379            "multi" => local_var_req_builder.query(
6380                &local_var_str
6381                    .into_iter()
6382                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6384            ),
6385            _ => local_var_req_builder.query(&[(
6386                "id__lt",
6387                &local_var_str
6388                    .into_iter()
6389                    .map(|p| p.to_string())
6390                    .collect::<Vec<String>>()
6391                    .join(",")
6392                    .to_string(),
6393            )]),
6394        };
6395    }
6396    if let Some(ref local_var_str) = id__lte {
6397        local_var_req_builder = match "multi" {
6398            "multi" => local_var_req_builder.query(
6399                &local_var_str
6400                    .into_iter()
6401                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6403            ),
6404            _ => local_var_req_builder.query(&[(
6405                "id__lte",
6406                &local_var_str
6407                    .into_iter()
6408                    .map(|p| p.to_string())
6409                    .collect::<Vec<String>>()
6410                    .join(",")
6411                    .to_string(),
6412            )]),
6413        };
6414    }
6415    if let Some(ref local_var_str) = id__n {
6416        local_var_req_builder = match "multi" {
6417            "multi" => local_var_req_builder.query(
6418                &local_var_str
6419                    .into_iter()
6420                    .map(|p| ("id__n".to_owned(), p.to_string()))
6421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6422            ),
6423            _ => local_var_req_builder.query(&[(
6424                "id__n",
6425                &local_var_str
6426                    .into_iter()
6427                    .map(|p| p.to_string())
6428                    .collect::<Vec<String>>()
6429                    .join(",")
6430                    .to_string(),
6431            )]),
6432        };
6433    }
6434    if let Some(ref local_var_str) = key {
6435        local_var_req_builder = match "multi" {
6436            "multi" => local_var_req_builder.query(
6437                &local_var_str
6438                    .into_iter()
6439                    .map(|p| ("key".to_owned(), p.to_string()))
6440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6441            ),
6442            _ => local_var_req_builder.query(&[(
6443                "key",
6444                &local_var_str
6445                    .into_iter()
6446                    .map(|p| p.to_string())
6447                    .collect::<Vec<String>>()
6448                    .join(",")
6449                    .to_string(),
6450            )]),
6451        };
6452    }
6453    if let Some(ref local_var_str) = key__empty {
6454        local_var_req_builder =
6455            local_var_req_builder.query(&[("key__empty", &local_var_str.to_string())]);
6456    }
6457    if let Some(ref local_var_str) = key__ic {
6458        local_var_req_builder = match "multi" {
6459            "multi" => local_var_req_builder.query(
6460                &local_var_str
6461                    .into_iter()
6462                    .map(|p| ("key__ic".to_owned(), p.to_string()))
6463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6464            ),
6465            _ => local_var_req_builder.query(&[(
6466                "key__ic",
6467                &local_var_str
6468                    .into_iter()
6469                    .map(|p| p.to_string())
6470                    .collect::<Vec<String>>()
6471                    .join(",")
6472                    .to_string(),
6473            )]),
6474        };
6475    }
6476    if let Some(ref local_var_str) = key__ie {
6477        local_var_req_builder = match "multi" {
6478            "multi" => local_var_req_builder.query(
6479                &local_var_str
6480                    .into_iter()
6481                    .map(|p| ("key__ie".to_owned(), p.to_string()))
6482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6483            ),
6484            _ => local_var_req_builder.query(&[(
6485                "key__ie",
6486                &local_var_str
6487                    .into_iter()
6488                    .map(|p| p.to_string())
6489                    .collect::<Vec<String>>()
6490                    .join(",")
6491                    .to_string(),
6492            )]),
6493        };
6494    }
6495    if let Some(ref local_var_str) = key__iew {
6496        local_var_req_builder = match "multi" {
6497            "multi" => local_var_req_builder.query(
6498                &local_var_str
6499                    .into_iter()
6500                    .map(|p| ("key__iew".to_owned(), p.to_string()))
6501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6502            ),
6503            _ => local_var_req_builder.query(&[(
6504                "key__iew",
6505                &local_var_str
6506                    .into_iter()
6507                    .map(|p| p.to_string())
6508                    .collect::<Vec<String>>()
6509                    .join(",")
6510                    .to_string(),
6511            )]),
6512        };
6513    }
6514    if let Some(ref local_var_str) = key__iregex {
6515        local_var_req_builder = match "multi" {
6516            "multi" => local_var_req_builder.query(
6517                &local_var_str
6518                    .into_iter()
6519                    .map(|p| ("key__iregex".to_owned(), p.to_string()))
6520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6521            ),
6522            _ => local_var_req_builder.query(&[(
6523                "key__iregex",
6524                &local_var_str
6525                    .into_iter()
6526                    .map(|p| p.to_string())
6527                    .collect::<Vec<String>>()
6528                    .join(",")
6529                    .to_string(),
6530            )]),
6531        };
6532    }
6533    if let Some(ref local_var_str) = key__isw {
6534        local_var_req_builder = match "multi" {
6535            "multi" => local_var_req_builder.query(
6536                &local_var_str
6537                    .into_iter()
6538                    .map(|p| ("key__isw".to_owned(), p.to_string()))
6539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6540            ),
6541            _ => local_var_req_builder.query(&[(
6542                "key__isw",
6543                &local_var_str
6544                    .into_iter()
6545                    .map(|p| p.to_string())
6546                    .collect::<Vec<String>>()
6547                    .join(",")
6548                    .to_string(),
6549            )]),
6550        };
6551    }
6552    if let Some(ref local_var_str) = key__n {
6553        local_var_req_builder = match "multi" {
6554            "multi" => local_var_req_builder.query(
6555                &local_var_str
6556                    .into_iter()
6557                    .map(|p| ("key__n".to_owned(), p.to_string()))
6558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6559            ),
6560            _ => local_var_req_builder.query(&[(
6561                "key__n",
6562                &local_var_str
6563                    .into_iter()
6564                    .map(|p| p.to_string())
6565                    .collect::<Vec<String>>()
6566                    .join(",")
6567                    .to_string(),
6568            )]),
6569        };
6570    }
6571    if let Some(ref local_var_str) = key__nic {
6572        local_var_req_builder = match "multi" {
6573            "multi" => local_var_req_builder.query(
6574                &local_var_str
6575                    .into_iter()
6576                    .map(|p| ("key__nic".to_owned(), p.to_string()))
6577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6578            ),
6579            _ => local_var_req_builder.query(&[(
6580                "key__nic",
6581                &local_var_str
6582                    .into_iter()
6583                    .map(|p| p.to_string())
6584                    .collect::<Vec<String>>()
6585                    .join(",")
6586                    .to_string(),
6587            )]),
6588        };
6589    }
6590    if let Some(ref local_var_str) = key__nie {
6591        local_var_req_builder = match "multi" {
6592            "multi" => local_var_req_builder.query(
6593                &local_var_str
6594                    .into_iter()
6595                    .map(|p| ("key__nie".to_owned(), p.to_string()))
6596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6597            ),
6598            _ => local_var_req_builder.query(&[(
6599                "key__nie",
6600                &local_var_str
6601                    .into_iter()
6602                    .map(|p| p.to_string())
6603                    .collect::<Vec<String>>()
6604                    .join(",")
6605                    .to_string(),
6606            )]),
6607        };
6608    }
6609    if let Some(ref local_var_str) = key__niew {
6610        local_var_req_builder = match "multi" {
6611            "multi" => local_var_req_builder.query(
6612                &local_var_str
6613                    .into_iter()
6614                    .map(|p| ("key__niew".to_owned(), p.to_string()))
6615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6616            ),
6617            _ => local_var_req_builder.query(&[(
6618                "key__niew",
6619                &local_var_str
6620                    .into_iter()
6621                    .map(|p| p.to_string())
6622                    .collect::<Vec<String>>()
6623                    .join(",")
6624                    .to_string(),
6625            )]),
6626        };
6627    }
6628    if let Some(ref local_var_str) = key__nisw {
6629        local_var_req_builder = match "multi" {
6630            "multi" => local_var_req_builder.query(
6631                &local_var_str
6632                    .into_iter()
6633                    .map(|p| ("key__nisw".to_owned(), p.to_string()))
6634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6635            ),
6636            _ => local_var_req_builder.query(&[(
6637                "key__nisw",
6638                &local_var_str
6639                    .into_iter()
6640                    .map(|p| p.to_string())
6641                    .collect::<Vec<String>>()
6642                    .join(",")
6643                    .to_string(),
6644            )]),
6645        };
6646    }
6647    if let Some(ref local_var_str) = key__regex {
6648        local_var_req_builder = match "multi" {
6649            "multi" => local_var_req_builder.query(
6650                &local_var_str
6651                    .into_iter()
6652                    .map(|p| ("key__regex".to_owned(), p.to_string()))
6653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6654            ),
6655            _ => local_var_req_builder.query(&[(
6656                "key__regex",
6657                &local_var_str
6658                    .into_iter()
6659                    .map(|p| p.to_string())
6660                    .collect::<Vec<String>>()
6661                    .join(",")
6662                    .to_string(),
6663            )]),
6664        };
6665    }
6666    if let Some(ref local_var_str) = last_used {
6667        local_var_req_builder =
6668            local_var_req_builder.query(&[("last_used", &local_var_str.to_string())]);
6669    }
6670    if let Some(ref local_var_str) = last_used__gte {
6671        local_var_req_builder =
6672            local_var_req_builder.query(&[("last_used__gte", &local_var_str.to_string())]);
6673    }
6674    if let Some(ref local_var_str) = last_used__lte {
6675        local_var_req_builder =
6676            local_var_req_builder.query(&[("last_used__lte", &local_var_str.to_string())]);
6677    }
6678    if let Some(ref local_var_str) = limit {
6679        local_var_req_builder =
6680            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6681    }
6682    if let Some(ref local_var_str) = offset {
6683        local_var_req_builder =
6684            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6685    }
6686    if let Some(ref local_var_str) = ordering {
6687        local_var_req_builder =
6688            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
6689    }
6690    if let Some(ref local_var_str) = pepper_id {
6691        local_var_req_builder = match "multi" {
6692            "multi" => local_var_req_builder.query(
6693                &local_var_str
6694                    .into_iter()
6695                    .map(|p| ("pepper_id".to_owned(), p.to_string()))
6696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6697            ),
6698            _ => local_var_req_builder.query(&[(
6699                "pepper_id",
6700                &local_var_str
6701                    .into_iter()
6702                    .map(|p| p.to_string())
6703                    .collect::<Vec<String>>()
6704                    .join(",")
6705                    .to_string(),
6706            )]),
6707        };
6708    }
6709    if let Some(ref local_var_str) = pepper_id__empty {
6710        local_var_req_builder =
6711            local_var_req_builder.query(&[("pepper_id__empty", &local_var_str.to_string())]);
6712    }
6713    if let Some(ref local_var_str) = pepper_id__gt {
6714        local_var_req_builder = match "multi" {
6715            "multi" => local_var_req_builder.query(
6716                &local_var_str
6717                    .into_iter()
6718                    .map(|p| ("pepper_id__gt".to_owned(), p.to_string()))
6719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6720            ),
6721            _ => local_var_req_builder.query(&[(
6722                "pepper_id__gt",
6723                &local_var_str
6724                    .into_iter()
6725                    .map(|p| p.to_string())
6726                    .collect::<Vec<String>>()
6727                    .join(",")
6728                    .to_string(),
6729            )]),
6730        };
6731    }
6732    if let Some(ref local_var_str) = pepper_id__gte {
6733        local_var_req_builder = match "multi" {
6734            "multi" => local_var_req_builder.query(
6735                &local_var_str
6736                    .into_iter()
6737                    .map(|p| ("pepper_id__gte".to_owned(), p.to_string()))
6738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6739            ),
6740            _ => local_var_req_builder.query(&[(
6741                "pepper_id__gte",
6742                &local_var_str
6743                    .into_iter()
6744                    .map(|p| p.to_string())
6745                    .collect::<Vec<String>>()
6746                    .join(",")
6747                    .to_string(),
6748            )]),
6749        };
6750    }
6751    if let Some(ref local_var_str) = pepper_id__lt {
6752        local_var_req_builder = match "multi" {
6753            "multi" => local_var_req_builder.query(
6754                &local_var_str
6755                    .into_iter()
6756                    .map(|p| ("pepper_id__lt".to_owned(), p.to_string()))
6757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6758            ),
6759            _ => local_var_req_builder.query(&[(
6760                "pepper_id__lt",
6761                &local_var_str
6762                    .into_iter()
6763                    .map(|p| p.to_string())
6764                    .collect::<Vec<String>>()
6765                    .join(",")
6766                    .to_string(),
6767            )]),
6768        };
6769    }
6770    if let Some(ref local_var_str) = pepper_id__lte {
6771        local_var_req_builder = match "multi" {
6772            "multi" => local_var_req_builder.query(
6773                &local_var_str
6774                    .into_iter()
6775                    .map(|p| ("pepper_id__lte".to_owned(), p.to_string()))
6776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6777            ),
6778            _ => local_var_req_builder.query(&[(
6779                "pepper_id__lte",
6780                &local_var_str
6781                    .into_iter()
6782                    .map(|p| p.to_string())
6783                    .collect::<Vec<String>>()
6784                    .join(",")
6785                    .to_string(),
6786            )]),
6787        };
6788    }
6789    if let Some(ref local_var_str) = pepper_id__n {
6790        local_var_req_builder = match "multi" {
6791            "multi" => local_var_req_builder.query(
6792                &local_var_str
6793                    .into_iter()
6794                    .map(|p| ("pepper_id__n".to_owned(), p.to_string()))
6795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6796            ),
6797            _ => local_var_req_builder.query(&[(
6798                "pepper_id__n",
6799                &local_var_str
6800                    .into_iter()
6801                    .map(|p| p.to_string())
6802                    .collect::<Vec<String>>()
6803                    .join(",")
6804                    .to_string(),
6805            )]),
6806        };
6807    }
6808    if let Some(ref local_var_str) = q {
6809        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6810    }
6811    if let Some(ref local_var_str) = start {
6812        local_var_req_builder =
6813            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
6814    }
6815    if let Some(ref local_var_str) = user {
6816        local_var_req_builder = match "multi" {
6817            "multi" => local_var_req_builder.query(
6818                &local_var_str
6819                    .into_iter()
6820                    .map(|p| ("user".to_owned(), p.to_string()))
6821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6822            ),
6823            _ => local_var_req_builder.query(&[(
6824                "user",
6825                &local_var_str
6826                    .into_iter()
6827                    .map(|p| p.to_string())
6828                    .collect::<Vec<String>>()
6829                    .join(",")
6830                    .to_string(),
6831            )]),
6832        };
6833    }
6834    if let Some(ref local_var_str) = user__n {
6835        local_var_req_builder = match "multi" {
6836            "multi" => local_var_req_builder.query(
6837                &local_var_str
6838                    .into_iter()
6839                    .map(|p| ("user__n".to_owned(), p.to_string()))
6840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6841            ),
6842            _ => local_var_req_builder.query(&[(
6843                "user__n",
6844                &local_var_str
6845                    .into_iter()
6846                    .map(|p| p.to_string())
6847                    .collect::<Vec<String>>()
6848                    .join(",")
6849                    .to_string(),
6850            )]),
6851        };
6852    }
6853    if let Some(ref local_var_str) = user_id {
6854        local_var_req_builder = match "multi" {
6855            "multi" => local_var_req_builder.query(
6856                &local_var_str
6857                    .into_iter()
6858                    .map(|p| ("user_id".to_owned(), p.to_string()))
6859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6860            ),
6861            _ => local_var_req_builder.query(&[(
6862                "user_id",
6863                &local_var_str
6864                    .into_iter()
6865                    .map(|p| p.to_string())
6866                    .collect::<Vec<String>>()
6867                    .join(",")
6868                    .to_string(),
6869            )]),
6870        };
6871    }
6872    if let Some(ref local_var_str) = user_id__n {
6873        local_var_req_builder = match "multi" {
6874            "multi" => local_var_req_builder.query(
6875                &local_var_str
6876                    .into_iter()
6877                    .map(|p| ("user_id__n".to_owned(), p.to_string()))
6878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6879            ),
6880            _ => local_var_req_builder.query(&[(
6881                "user_id__n",
6882                &local_var_str
6883                    .into_iter()
6884                    .map(|p| p.to_string())
6885                    .collect::<Vec<String>>()
6886                    .join(",")
6887                    .to_string(),
6888            )]),
6889        };
6890    }
6891    if let Some(ref local_var_str) = version {
6892        local_var_req_builder =
6893            local_var_req_builder.query(&[("version", &local_var_str.to_string())]);
6894    }
6895    if let Some(ref local_var_str) = version__ic {
6896        local_var_req_builder = match "multi" {
6897            "multi" => local_var_req_builder.query(
6898                &local_var_str
6899                    .into_iter()
6900                    .map(|p| ("version__ic".to_owned(), p.to_string()))
6901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6902            ),
6903            _ => local_var_req_builder.query(&[(
6904                "version__ic",
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) = version__ie {
6915        local_var_req_builder = match "multi" {
6916            "multi" => local_var_req_builder.query(
6917                &local_var_str
6918                    .into_iter()
6919                    .map(|p| ("version__ie".to_owned(), p.to_string()))
6920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6921            ),
6922            _ => local_var_req_builder.query(&[(
6923                "version__ie",
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) = version__iew {
6934        local_var_req_builder = match "multi" {
6935            "multi" => local_var_req_builder.query(
6936                &local_var_str
6937                    .into_iter()
6938                    .map(|p| ("version__iew".to_owned(), p.to_string()))
6939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6940            ),
6941            _ => local_var_req_builder.query(&[(
6942                "version__iew",
6943                &local_var_str
6944                    .into_iter()
6945                    .map(|p| p.to_string())
6946                    .collect::<Vec<String>>()
6947                    .join(",")
6948                    .to_string(),
6949            )]),
6950        };
6951    }
6952    if let Some(ref local_var_str) = version__iregex {
6953        local_var_req_builder = match "multi" {
6954            "multi" => local_var_req_builder.query(
6955                &local_var_str
6956                    .into_iter()
6957                    .map(|p| ("version__iregex".to_owned(), p.to_string()))
6958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6959            ),
6960            _ => local_var_req_builder.query(&[(
6961                "version__iregex",
6962                &local_var_str
6963                    .into_iter()
6964                    .map(|p| p.to_string())
6965                    .collect::<Vec<String>>()
6966                    .join(",")
6967                    .to_string(),
6968            )]),
6969        };
6970    }
6971    if let Some(ref local_var_str) = version__isw {
6972        local_var_req_builder = match "multi" {
6973            "multi" => local_var_req_builder.query(
6974                &local_var_str
6975                    .into_iter()
6976                    .map(|p| ("version__isw".to_owned(), p.to_string()))
6977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6978            ),
6979            _ => local_var_req_builder.query(&[(
6980                "version__isw",
6981                &local_var_str
6982                    .into_iter()
6983                    .map(|p| p.to_string())
6984                    .collect::<Vec<String>>()
6985                    .join(",")
6986                    .to_string(),
6987            )]),
6988        };
6989    }
6990    if let Some(ref local_var_str) = version__n {
6991        local_var_req_builder =
6992            local_var_req_builder.query(&[("version__n", &local_var_str.to_string())]);
6993    }
6994    if let Some(ref local_var_str) = version__nic {
6995        local_var_req_builder = match "multi" {
6996            "multi" => local_var_req_builder.query(
6997                &local_var_str
6998                    .into_iter()
6999                    .map(|p| ("version__nic".to_owned(), p.to_string()))
7000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7001            ),
7002            _ => local_var_req_builder.query(&[(
7003                "version__nic",
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) = version__nie {
7014        local_var_req_builder = match "multi" {
7015            "multi" => local_var_req_builder.query(
7016                &local_var_str
7017                    .into_iter()
7018                    .map(|p| ("version__nie".to_owned(), p.to_string()))
7019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7020            ),
7021            _ => local_var_req_builder.query(&[(
7022                "version__nie",
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) = version__niew {
7033        local_var_req_builder = match "multi" {
7034            "multi" => local_var_req_builder.query(
7035                &local_var_str
7036                    .into_iter()
7037                    .map(|p| ("version__niew".to_owned(), p.to_string()))
7038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7039            ),
7040            _ => local_var_req_builder.query(&[(
7041                "version__niew",
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) = version__nisw {
7052        local_var_req_builder = match "multi" {
7053            "multi" => local_var_req_builder.query(
7054                &local_var_str
7055                    .into_iter()
7056                    .map(|p| ("version__nisw".to_owned(), p.to_string()))
7057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7058            ),
7059            _ => local_var_req_builder.query(&[(
7060                "version__nisw",
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) = version__regex {
7071        local_var_req_builder = match "multi" {
7072            "multi" => local_var_req_builder.query(
7073                &local_var_str
7074                    .into_iter()
7075                    .map(|p| ("version__regex".to_owned(), p.to_string()))
7076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7077            ),
7078            _ => local_var_req_builder.query(&[(
7079                "version__regex",
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) = write_enabled {
7090        local_var_req_builder =
7091            local_var_req_builder.query(&[("write_enabled", &local_var_str.to_string())]);
7092    }
7093    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7094        local_var_req_builder =
7095            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7096    }
7097    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7098        let local_var_key = local_var_apikey.key.clone();
7099        let local_var_value = match local_var_apikey.prefix {
7100            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7101            None => local_var_key,
7102        };
7103        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7104    };
7105
7106    let local_var_req = local_var_req_builder.build()?;
7107    let local_var_resp = local_var_client.execute(local_var_req).await?;
7108
7109    let local_var_status = local_var_resp.status();
7110    let local_var_content = local_var_resp.text().await?;
7111
7112    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7113        serde_json::from_str(&local_var_content).map_err(Error::from)
7114    } else {
7115        let local_var_entity: Option<UsersTokensListError> =
7116            serde_json::from_str(&local_var_content).ok();
7117        let local_var_error = ResponseContent {
7118            status: local_var_status,
7119            content: local_var_content,
7120            entity: local_var_entity,
7121        };
7122        Err(Error::ResponseError(local_var_error))
7123    }
7124}
7125
7126/// Patch a token object.
7127pub async fn users_tokens_partial_update(
7128    configuration: &configuration::Configuration,
7129    id: i32,
7130    patched_token_request: Option<crate::models::PatchedTokenRequest>,
7131) -> Result<crate::models::Token, Error<UsersTokensPartialUpdateError>> {
7132    let local_var_configuration = configuration;
7133
7134    let local_var_client = &local_var_configuration.client;
7135
7136    let local_var_uri_str = format!(
7137        "{}/api/users/tokens/{id}/",
7138        local_var_configuration.base_path,
7139        id = id
7140    );
7141    let mut local_var_req_builder =
7142        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7143
7144    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7145        local_var_req_builder =
7146            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7147    }
7148    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7149        let local_var_key = local_var_apikey.key.clone();
7150        let local_var_value = match local_var_apikey.prefix {
7151            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7152            None => local_var_key,
7153        };
7154        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7155    };
7156    local_var_req_builder = local_var_req_builder.json(&patched_token_request);
7157
7158    let local_var_req = local_var_req_builder.build()?;
7159    let local_var_resp = local_var_client.execute(local_var_req).await?;
7160
7161    let local_var_status = local_var_resp.status();
7162    let local_var_content = local_var_resp.text().await?;
7163
7164    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7165        serde_json::from_str(&local_var_content).map_err(Error::from)
7166    } else {
7167        let local_var_entity: Option<UsersTokensPartialUpdateError> =
7168            serde_json::from_str(&local_var_content).ok();
7169        let local_var_error = ResponseContent {
7170            status: local_var_status,
7171            content: local_var_content,
7172            entity: local_var_entity,
7173        };
7174        Err(Error::ResponseError(local_var_error))
7175    }
7176}
7177
7178/// Non-authenticated REST API endpoint via which a user may create a Token.
7179pub async fn users_tokens_provision_create(
7180    configuration: &configuration::Configuration,
7181    token_provision_request: crate::models::TokenProvisionRequest,
7182) -> Result<crate::models::TokenProvision, Error<UsersTokensProvisionCreateError>> {
7183    let local_var_configuration = configuration;
7184
7185    let local_var_client = &local_var_configuration.client;
7186
7187    let local_var_uri_str = format!(
7188        "{}/api/users/tokens/provision/",
7189        local_var_configuration.base_path
7190    );
7191    let mut local_var_req_builder =
7192        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7193
7194    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7195        local_var_req_builder =
7196            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7197    }
7198    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7199        let local_var_key = local_var_apikey.key.clone();
7200        let local_var_value = match local_var_apikey.prefix {
7201            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7202            None => local_var_key,
7203        };
7204        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7205    };
7206    local_var_req_builder = local_var_req_builder.json(&token_provision_request);
7207
7208    let local_var_req = local_var_req_builder.build()?;
7209    let local_var_resp = local_var_client.execute(local_var_req).await?;
7210
7211    let local_var_status = local_var_resp.status();
7212    let local_var_content = local_var_resp.text().await?;
7213
7214    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7215        serde_json::from_str(&local_var_content).map_err(Error::from)
7216    } else {
7217        let local_var_entity: Option<UsersTokensProvisionCreateError> =
7218            serde_json::from_str(&local_var_content).ok();
7219        let local_var_error = ResponseContent {
7220            status: local_var_status,
7221            content: local_var_content,
7222            entity: local_var_entity,
7223        };
7224        Err(Error::ResponseError(local_var_error))
7225    }
7226}
7227
7228/// Get a token object.
7229pub async fn users_tokens_retrieve(
7230    configuration: &configuration::Configuration,
7231    id: i32,
7232) -> Result<crate::models::Token, Error<UsersTokensRetrieveError>> {
7233    let local_var_configuration = configuration;
7234
7235    let local_var_client = &local_var_configuration.client;
7236
7237    let local_var_uri_str = format!(
7238        "{}/api/users/tokens/{id}/",
7239        local_var_configuration.base_path,
7240        id = id
7241    );
7242    let mut local_var_req_builder =
7243        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7244
7245    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7246        local_var_req_builder =
7247            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7248    }
7249    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7250        let local_var_key = local_var_apikey.key.clone();
7251        let local_var_value = match local_var_apikey.prefix {
7252            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7253            None => local_var_key,
7254        };
7255        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7256    };
7257
7258    let local_var_req = local_var_req_builder.build()?;
7259    let local_var_resp = local_var_client.execute(local_var_req).await?;
7260
7261    let local_var_status = local_var_resp.status();
7262    let local_var_content = local_var_resp.text().await?;
7263
7264    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7265        serde_json::from_str(&local_var_content).map_err(Error::from)
7266    } else {
7267        let local_var_entity: Option<UsersTokensRetrieveError> =
7268            serde_json::from_str(&local_var_content).ok();
7269        let local_var_error = ResponseContent {
7270            status: local_var_status,
7271            content: local_var_content,
7272            entity: local_var_entity,
7273        };
7274        Err(Error::ResponseError(local_var_error))
7275    }
7276}
7277
7278/// Put a token object.
7279pub async fn users_tokens_update(
7280    configuration: &configuration::Configuration,
7281    id: i32,
7282    token_request: crate::models::TokenRequest,
7283) -> Result<crate::models::Token, Error<UsersTokensUpdateError>> {
7284    let local_var_configuration = configuration;
7285
7286    let local_var_client = &local_var_configuration.client;
7287
7288    let local_var_uri_str = format!(
7289        "{}/api/users/tokens/{id}/",
7290        local_var_configuration.base_path,
7291        id = id
7292    );
7293    let mut local_var_req_builder =
7294        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7295
7296    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7297        local_var_req_builder =
7298            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7299    }
7300    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7301        let local_var_key = local_var_apikey.key.clone();
7302        let local_var_value = match local_var_apikey.prefix {
7303            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7304            None => local_var_key,
7305        };
7306        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7307    };
7308    local_var_req_builder = local_var_req_builder.json(&token_request);
7309
7310    let local_var_req = local_var_req_builder.build()?;
7311    let local_var_resp = local_var_client.execute(local_var_req).await?;
7312
7313    let local_var_status = local_var_resp.status();
7314    let local_var_content = local_var_resp.text().await?;
7315
7316    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7317        serde_json::from_str(&local_var_content).map_err(Error::from)
7318    } else {
7319        let local_var_entity: Option<UsersTokensUpdateError> =
7320            serde_json::from_str(&local_var_content).ok();
7321        let local_var_error = ResponseContent {
7322            status: local_var_status,
7323            content: local_var_content,
7324            entity: local_var_entity,
7325        };
7326        Err(Error::ResponseError(local_var_error))
7327    }
7328}
7329
7330/// Delete a list of user objects.
7331pub async fn users_users_bulk_destroy(
7332    configuration: &configuration::Configuration,
7333    user_request: Vec<crate::models::UserRequest>,
7334) -> Result<(), Error<UsersUsersBulkDestroyError>> {
7335    let local_var_configuration = configuration;
7336
7337    let local_var_client = &local_var_configuration.client;
7338
7339    let local_var_uri_str = format!("{}/api/users/users/", local_var_configuration.base_path);
7340    let mut local_var_req_builder =
7341        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7342
7343    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7344        local_var_req_builder =
7345            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7346    }
7347    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7348        let local_var_key = local_var_apikey.key.clone();
7349        let local_var_value = match local_var_apikey.prefix {
7350            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7351            None => local_var_key,
7352        };
7353        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7354    };
7355    local_var_req_builder = local_var_req_builder.json(&user_request);
7356
7357    let local_var_req = local_var_req_builder.build()?;
7358    let local_var_resp = local_var_client.execute(local_var_req).await?;
7359
7360    let local_var_status = local_var_resp.status();
7361    let local_var_content = local_var_resp.text().await?;
7362
7363    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7364        Ok(())
7365    } else {
7366        let local_var_entity: Option<UsersUsersBulkDestroyError> =
7367            serde_json::from_str(&local_var_content).ok();
7368        let local_var_error = ResponseContent {
7369            status: local_var_status,
7370            content: local_var_content,
7371            entity: local_var_entity,
7372        };
7373        Err(Error::ResponseError(local_var_error))
7374    }
7375}
7376
7377/// Patch a list of user objects.
7378pub async fn users_users_bulk_partial_update(
7379    configuration: &configuration::Configuration,
7380    user_request: Vec<crate::models::UserRequest>,
7381) -> Result<Vec<crate::models::User>, Error<UsersUsersBulkPartialUpdateError>> {
7382    let local_var_configuration = configuration;
7383
7384    let local_var_client = &local_var_configuration.client;
7385
7386    let local_var_uri_str = format!("{}/api/users/users/", local_var_configuration.base_path);
7387    let mut local_var_req_builder =
7388        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7389
7390    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7391        local_var_req_builder =
7392            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7393    }
7394    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7395        let local_var_key = local_var_apikey.key.clone();
7396        let local_var_value = match local_var_apikey.prefix {
7397            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7398            None => local_var_key,
7399        };
7400        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7401    };
7402    local_var_req_builder = local_var_req_builder.json(&user_request);
7403
7404    let local_var_req = local_var_req_builder.build()?;
7405    let local_var_resp = local_var_client.execute(local_var_req).await?;
7406
7407    let local_var_status = local_var_resp.status();
7408    let local_var_content = local_var_resp.text().await?;
7409
7410    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7411        serde_json::from_str(&local_var_content).map_err(Error::from)
7412    } else {
7413        let local_var_entity: Option<UsersUsersBulkPartialUpdateError> =
7414            serde_json::from_str(&local_var_content).ok();
7415        let local_var_error = ResponseContent {
7416            status: local_var_status,
7417            content: local_var_content,
7418            entity: local_var_entity,
7419        };
7420        Err(Error::ResponseError(local_var_error))
7421    }
7422}
7423
7424/// Put a list of user objects.
7425pub async fn users_users_bulk_update(
7426    configuration: &configuration::Configuration,
7427    user_request: Vec<crate::models::UserRequest>,
7428) -> Result<Vec<crate::models::User>, Error<UsersUsersBulkUpdateError>> {
7429    let local_var_configuration = configuration;
7430
7431    let local_var_client = &local_var_configuration.client;
7432
7433    let local_var_uri_str = format!("{}/api/users/users/", local_var_configuration.base_path);
7434    let mut local_var_req_builder =
7435        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7436
7437    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7438        local_var_req_builder =
7439            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7440    }
7441    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7442        let local_var_key = local_var_apikey.key.clone();
7443        let local_var_value = match local_var_apikey.prefix {
7444            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7445            None => local_var_key,
7446        };
7447        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7448    };
7449    local_var_req_builder = local_var_req_builder.json(&user_request);
7450
7451    let local_var_req = local_var_req_builder.build()?;
7452    let local_var_resp = local_var_client.execute(local_var_req).await?;
7453
7454    let local_var_status = local_var_resp.status();
7455    let local_var_content = local_var_resp.text().await?;
7456
7457    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7458        serde_json::from_str(&local_var_content).map_err(Error::from)
7459    } else {
7460        let local_var_entity: Option<UsersUsersBulkUpdateError> =
7461            serde_json::from_str(&local_var_content).ok();
7462        let local_var_error = ResponseContent {
7463            status: local_var_status,
7464            content: local_var_content,
7465            entity: local_var_entity,
7466        };
7467        Err(Error::ResponseError(local_var_error))
7468    }
7469}
7470
7471/// Post a list of user objects.
7472pub async fn users_users_create(
7473    configuration: &configuration::Configuration,
7474    users_users_create_request: crate::models::UsersUsersCreateRequest,
7475) -> Result<crate::models::User, Error<UsersUsersCreateError>> {
7476    let local_var_configuration = configuration;
7477
7478    let local_var_client = &local_var_configuration.client;
7479
7480    let local_var_uri_str = format!("{}/api/users/users/", local_var_configuration.base_path);
7481    let mut local_var_req_builder =
7482        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7483
7484    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7485        local_var_req_builder =
7486            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7487    }
7488    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7489        let local_var_key = local_var_apikey.key.clone();
7490        let local_var_value = match local_var_apikey.prefix {
7491            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7492            None => local_var_key,
7493        };
7494        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7495    };
7496    local_var_req_builder = local_var_req_builder.json(&users_users_create_request);
7497
7498    let local_var_req = local_var_req_builder.build()?;
7499    let local_var_resp = local_var_client.execute(local_var_req).await?;
7500
7501    let local_var_status = local_var_resp.status();
7502    let local_var_content = local_var_resp.text().await?;
7503
7504    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7505        serde_json::from_str(&local_var_content).map_err(Error::from)
7506    } else {
7507        let local_var_entity: Option<UsersUsersCreateError> =
7508            serde_json::from_str(&local_var_content).ok();
7509        let local_var_error = ResponseContent {
7510            status: local_var_status,
7511            content: local_var_content,
7512            entity: local_var_entity,
7513        };
7514        Err(Error::ResponseError(local_var_error))
7515    }
7516}
7517
7518/// Delete a user object.
7519pub async fn users_users_destroy(
7520    configuration: &configuration::Configuration,
7521    id: i32,
7522) -> Result<(), Error<UsersUsersDestroyError>> {
7523    let local_var_configuration = configuration;
7524
7525    let local_var_client = &local_var_configuration.client;
7526
7527    let local_var_uri_str = format!(
7528        "{}/api/users/users/{id}/",
7529        local_var_configuration.base_path,
7530        id = id
7531    );
7532    let mut local_var_req_builder =
7533        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7534
7535    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7536        local_var_req_builder =
7537            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7538    }
7539    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7540        let local_var_key = local_var_apikey.key.clone();
7541        let local_var_value = match local_var_apikey.prefix {
7542            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7543            None => local_var_key,
7544        };
7545        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7546    };
7547
7548    let local_var_req = local_var_req_builder.build()?;
7549    let local_var_resp = local_var_client.execute(local_var_req).await?;
7550
7551    let local_var_status = local_var_resp.status();
7552    let local_var_content = local_var_resp.text().await?;
7553
7554    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7555        Ok(())
7556    } else {
7557        let local_var_entity: Option<UsersUsersDestroyError> =
7558            serde_json::from_str(&local_var_content).ok();
7559        let local_var_error = ResponseContent {
7560            status: local_var_status,
7561            content: local_var_content,
7562            entity: local_var_entity,
7563        };
7564        Err(Error::ResponseError(local_var_error))
7565    }
7566}
7567
7568/// Get a list of user objects.
7569pub async fn users_users_list(
7570    configuration: &configuration::Configuration,
7571    date_joined: Option<Vec<String>>,
7572    date_joined__empty: Option<bool>,
7573    date_joined__gt: Option<Vec<String>>,
7574    date_joined__gte: Option<Vec<String>>,
7575    date_joined__lt: Option<Vec<String>>,
7576    date_joined__lte: Option<Vec<String>>,
7577    date_joined__n: Option<Vec<String>>,
7578    email: Option<Vec<String>>,
7579    email__empty: Option<bool>,
7580    email__ic: Option<Vec<String>>,
7581    email__ie: Option<Vec<String>>,
7582    email__iew: Option<Vec<String>>,
7583    email__iregex: Option<Vec<String>>,
7584    email__isw: Option<Vec<String>>,
7585    email__n: Option<Vec<String>>,
7586    email__nic: Option<Vec<String>>,
7587    email__nie: Option<Vec<String>>,
7588    email__niew: Option<Vec<String>>,
7589    email__nisw: Option<Vec<String>>,
7590    email__regex: Option<Vec<String>>,
7591    first_name: Option<Vec<String>>,
7592    first_name__empty: Option<bool>,
7593    first_name__ic: Option<Vec<String>>,
7594    first_name__ie: Option<Vec<String>>,
7595    first_name__iew: Option<Vec<String>>,
7596    first_name__iregex: Option<Vec<String>>,
7597    first_name__isw: Option<Vec<String>>,
7598    first_name__n: Option<Vec<String>>,
7599    first_name__nic: Option<Vec<String>>,
7600    first_name__nie: Option<Vec<String>>,
7601    first_name__niew: Option<Vec<String>>,
7602    first_name__nisw: Option<Vec<String>>,
7603    first_name__regex: Option<Vec<String>>,
7604    group: Option<Vec<String>>,
7605    group__n: Option<Vec<String>>,
7606    group_id: Option<Vec<i32>>,
7607    group_id__n: Option<Vec<i32>>,
7608    id: Option<Vec<i32>>,
7609    id__empty: Option<bool>,
7610    id__gt: Option<Vec<i32>>,
7611    id__gte: Option<Vec<i32>>,
7612    id__lt: Option<Vec<i32>>,
7613    id__lte: Option<Vec<i32>>,
7614    id__n: Option<Vec<i32>>,
7615    is_active: Option<bool>,
7616    is_superuser: Option<bool>,
7617    last_login: Option<Vec<String>>,
7618    last_login__empty: Option<bool>,
7619    last_login__gt: Option<Vec<String>>,
7620    last_login__gte: Option<Vec<String>>,
7621    last_login__lt: Option<Vec<String>>,
7622    last_login__lte: Option<Vec<String>>,
7623    last_login__n: Option<Vec<String>>,
7624    last_name: Option<Vec<String>>,
7625    last_name__empty: Option<bool>,
7626    last_name__ic: Option<Vec<String>>,
7627    last_name__ie: Option<Vec<String>>,
7628    last_name__iew: Option<Vec<String>>,
7629    last_name__iregex: Option<Vec<String>>,
7630    last_name__isw: Option<Vec<String>>,
7631    last_name__n: Option<Vec<String>>,
7632    last_name__nic: Option<Vec<String>>,
7633    last_name__nie: Option<Vec<String>>,
7634    last_name__niew: Option<Vec<String>>,
7635    last_name__nisw: Option<Vec<String>>,
7636    last_name__regex: Option<Vec<String>>,
7637    limit: Option<i32>,
7638    notification_group_id: Option<Vec<i32>>,
7639    notification_group_id__n: Option<Vec<i32>>,
7640    offset: Option<i32>,
7641    ordering: Option<&str>,
7642    owner: Option<Vec<String>>,
7643    owner__n: Option<Vec<String>>,
7644    owner_id: Option<Vec<i32>>,
7645    owner_id__n: Option<Vec<i32>>,
7646    permission_id: Option<Vec<i32>>,
7647    permission_id__n: Option<Vec<i32>>,
7648    q: Option<&str>,
7649    start: Option<i32>,
7650    username: Option<Vec<String>>,
7651    username__empty: Option<bool>,
7652    username__ic: Option<Vec<String>>,
7653    username__ie: Option<Vec<String>>,
7654    username__iew: Option<Vec<String>>,
7655    username__iregex: Option<Vec<String>>,
7656    username__isw: Option<Vec<String>>,
7657    username__n: Option<Vec<String>>,
7658    username__nic: Option<Vec<String>>,
7659    username__nie: Option<Vec<String>>,
7660    username__niew: Option<Vec<String>>,
7661    username__nisw: Option<Vec<String>>,
7662    username__regex: Option<Vec<String>>,
7663) -> Result<crate::models::PaginatedUserList, Error<UsersUsersListError>> {
7664    let local_var_configuration = configuration;
7665
7666    let local_var_client = &local_var_configuration.client;
7667
7668    let local_var_uri_str = format!("{}/api/users/users/", local_var_configuration.base_path);
7669    let mut local_var_req_builder =
7670        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7671
7672    if let Some(ref local_var_str) = date_joined {
7673        local_var_req_builder = match "multi" {
7674            "multi" => local_var_req_builder.query(
7675                &local_var_str
7676                    .into_iter()
7677                    .map(|p| ("date_joined".to_owned(), p.to_string()))
7678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7679            ),
7680            _ => local_var_req_builder.query(&[(
7681                "date_joined",
7682                &local_var_str
7683                    .into_iter()
7684                    .map(|p| p.to_string())
7685                    .collect::<Vec<String>>()
7686                    .join(",")
7687                    .to_string(),
7688            )]),
7689        };
7690    }
7691    if let Some(ref local_var_str) = date_joined__empty {
7692        local_var_req_builder =
7693            local_var_req_builder.query(&[("date_joined__empty", &local_var_str.to_string())]);
7694    }
7695    if let Some(ref local_var_str) = date_joined__gt {
7696        local_var_req_builder = match "multi" {
7697            "multi" => local_var_req_builder.query(
7698                &local_var_str
7699                    .into_iter()
7700                    .map(|p| ("date_joined__gt".to_owned(), p.to_string()))
7701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7702            ),
7703            _ => local_var_req_builder.query(&[(
7704                "date_joined__gt",
7705                &local_var_str
7706                    .into_iter()
7707                    .map(|p| p.to_string())
7708                    .collect::<Vec<String>>()
7709                    .join(",")
7710                    .to_string(),
7711            )]),
7712        };
7713    }
7714    if let Some(ref local_var_str) = date_joined__gte {
7715        local_var_req_builder = match "multi" {
7716            "multi" => local_var_req_builder.query(
7717                &local_var_str
7718                    .into_iter()
7719                    .map(|p| ("date_joined__gte".to_owned(), p.to_string()))
7720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7721            ),
7722            _ => local_var_req_builder.query(&[(
7723                "date_joined__gte",
7724                &local_var_str
7725                    .into_iter()
7726                    .map(|p| p.to_string())
7727                    .collect::<Vec<String>>()
7728                    .join(",")
7729                    .to_string(),
7730            )]),
7731        };
7732    }
7733    if let Some(ref local_var_str) = date_joined__lt {
7734        local_var_req_builder = match "multi" {
7735            "multi" => local_var_req_builder.query(
7736                &local_var_str
7737                    .into_iter()
7738                    .map(|p| ("date_joined__lt".to_owned(), p.to_string()))
7739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7740            ),
7741            _ => local_var_req_builder.query(&[(
7742                "date_joined__lt",
7743                &local_var_str
7744                    .into_iter()
7745                    .map(|p| p.to_string())
7746                    .collect::<Vec<String>>()
7747                    .join(",")
7748                    .to_string(),
7749            )]),
7750        };
7751    }
7752    if let Some(ref local_var_str) = date_joined__lte {
7753        local_var_req_builder = match "multi" {
7754            "multi" => local_var_req_builder.query(
7755                &local_var_str
7756                    .into_iter()
7757                    .map(|p| ("date_joined__lte".to_owned(), p.to_string()))
7758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7759            ),
7760            _ => local_var_req_builder.query(&[(
7761                "date_joined__lte",
7762                &local_var_str
7763                    .into_iter()
7764                    .map(|p| p.to_string())
7765                    .collect::<Vec<String>>()
7766                    .join(",")
7767                    .to_string(),
7768            )]),
7769        };
7770    }
7771    if let Some(ref local_var_str) = date_joined__n {
7772        local_var_req_builder = match "multi" {
7773            "multi" => local_var_req_builder.query(
7774                &local_var_str
7775                    .into_iter()
7776                    .map(|p| ("date_joined__n".to_owned(), p.to_string()))
7777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7778            ),
7779            _ => local_var_req_builder.query(&[(
7780                "date_joined__n",
7781                &local_var_str
7782                    .into_iter()
7783                    .map(|p| p.to_string())
7784                    .collect::<Vec<String>>()
7785                    .join(",")
7786                    .to_string(),
7787            )]),
7788        };
7789    }
7790    if let Some(ref local_var_str) = email {
7791        local_var_req_builder = match "multi" {
7792            "multi" => local_var_req_builder.query(
7793                &local_var_str
7794                    .into_iter()
7795                    .map(|p| ("email".to_owned(), p.to_string()))
7796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7797            ),
7798            _ => local_var_req_builder.query(&[(
7799                "email",
7800                &local_var_str
7801                    .into_iter()
7802                    .map(|p| p.to_string())
7803                    .collect::<Vec<String>>()
7804                    .join(",")
7805                    .to_string(),
7806            )]),
7807        };
7808    }
7809    if let Some(ref local_var_str) = email__empty {
7810        local_var_req_builder =
7811            local_var_req_builder.query(&[("email__empty", &local_var_str.to_string())]);
7812    }
7813    if let Some(ref local_var_str) = email__ic {
7814        local_var_req_builder = match "multi" {
7815            "multi" => local_var_req_builder.query(
7816                &local_var_str
7817                    .into_iter()
7818                    .map(|p| ("email__ic".to_owned(), p.to_string()))
7819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7820            ),
7821            _ => local_var_req_builder.query(&[(
7822                "email__ic",
7823                &local_var_str
7824                    .into_iter()
7825                    .map(|p| p.to_string())
7826                    .collect::<Vec<String>>()
7827                    .join(",")
7828                    .to_string(),
7829            )]),
7830        };
7831    }
7832    if let Some(ref local_var_str) = email__ie {
7833        local_var_req_builder = match "multi" {
7834            "multi" => local_var_req_builder.query(
7835                &local_var_str
7836                    .into_iter()
7837                    .map(|p| ("email__ie".to_owned(), p.to_string()))
7838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7839            ),
7840            _ => local_var_req_builder.query(&[(
7841                "email__ie",
7842                &local_var_str
7843                    .into_iter()
7844                    .map(|p| p.to_string())
7845                    .collect::<Vec<String>>()
7846                    .join(",")
7847                    .to_string(),
7848            )]),
7849        };
7850    }
7851    if let Some(ref local_var_str) = email__iew {
7852        local_var_req_builder = match "multi" {
7853            "multi" => local_var_req_builder.query(
7854                &local_var_str
7855                    .into_iter()
7856                    .map(|p| ("email__iew".to_owned(), p.to_string()))
7857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7858            ),
7859            _ => local_var_req_builder.query(&[(
7860                "email__iew",
7861                &local_var_str
7862                    .into_iter()
7863                    .map(|p| p.to_string())
7864                    .collect::<Vec<String>>()
7865                    .join(",")
7866                    .to_string(),
7867            )]),
7868        };
7869    }
7870    if let Some(ref local_var_str) = email__iregex {
7871        local_var_req_builder = match "multi" {
7872            "multi" => local_var_req_builder.query(
7873                &local_var_str
7874                    .into_iter()
7875                    .map(|p| ("email__iregex".to_owned(), p.to_string()))
7876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7877            ),
7878            _ => local_var_req_builder.query(&[(
7879                "email__iregex",
7880                &local_var_str
7881                    .into_iter()
7882                    .map(|p| p.to_string())
7883                    .collect::<Vec<String>>()
7884                    .join(",")
7885                    .to_string(),
7886            )]),
7887        };
7888    }
7889    if let Some(ref local_var_str) = email__isw {
7890        local_var_req_builder = match "multi" {
7891            "multi" => local_var_req_builder.query(
7892                &local_var_str
7893                    .into_iter()
7894                    .map(|p| ("email__isw".to_owned(), p.to_string()))
7895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7896            ),
7897            _ => local_var_req_builder.query(&[(
7898                "email__isw",
7899                &local_var_str
7900                    .into_iter()
7901                    .map(|p| p.to_string())
7902                    .collect::<Vec<String>>()
7903                    .join(",")
7904                    .to_string(),
7905            )]),
7906        };
7907    }
7908    if let Some(ref local_var_str) = email__n {
7909        local_var_req_builder = match "multi" {
7910            "multi" => local_var_req_builder.query(
7911                &local_var_str
7912                    .into_iter()
7913                    .map(|p| ("email__n".to_owned(), p.to_string()))
7914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7915            ),
7916            _ => local_var_req_builder.query(&[(
7917                "email__n",
7918                &local_var_str
7919                    .into_iter()
7920                    .map(|p| p.to_string())
7921                    .collect::<Vec<String>>()
7922                    .join(",")
7923                    .to_string(),
7924            )]),
7925        };
7926    }
7927    if let Some(ref local_var_str) = email__nic {
7928        local_var_req_builder = match "multi" {
7929            "multi" => local_var_req_builder.query(
7930                &local_var_str
7931                    .into_iter()
7932                    .map(|p| ("email__nic".to_owned(), p.to_string()))
7933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7934            ),
7935            _ => local_var_req_builder.query(&[(
7936                "email__nic",
7937                &local_var_str
7938                    .into_iter()
7939                    .map(|p| p.to_string())
7940                    .collect::<Vec<String>>()
7941                    .join(",")
7942                    .to_string(),
7943            )]),
7944        };
7945    }
7946    if let Some(ref local_var_str) = email__nie {
7947        local_var_req_builder = match "multi" {
7948            "multi" => local_var_req_builder.query(
7949                &local_var_str
7950                    .into_iter()
7951                    .map(|p| ("email__nie".to_owned(), p.to_string()))
7952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7953            ),
7954            _ => local_var_req_builder.query(&[(
7955                "email__nie",
7956                &local_var_str
7957                    .into_iter()
7958                    .map(|p| p.to_string())
7959                    .collect::<Vec<String>>()
7960                    .join(",")
7961                    .to_string(),
7962            )]),
7963        };
7964    }
7965    if let Some(ref local_var_str) = email__niew {
7966        local_var_req_builder = match "multi" {
7967            "multi" => local_var_req_builder.query(
7968                &local_var_str
7969                    .into_iter()
7970                    .map(|p| ("email__niew".to_owned(), p.to_string()))
7971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7972            ),
7973            _ => local_var_req_builder.query(&[(
7974                "email__niew",
7975                &local_var_str
7976                    .into_iter()
7977                    .map(|p| p.to_string())
7978                    .collect::<Vec<String>>()
7979                    .join(",")
7980                    .to_string(),
7981            )]),
7982        };
7983    }
7984    if let Some(ref local_var_str) = email__nisw {
7985        local_var_req_builder = match "multi" {
7986            "multi" => local_var_req_builder.query(
7987                &local_var_str
7988                    .into_iter()
7989                    .map(|p| ("email__nisw".to_owned(), p.to_string()))
7990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7991            ),
7992            _ => local_var_req_builder.query(&[(
7993                "email__nisw",
7994                &local_var_str
7995                    .into_iter()
7996                    .map(|p| p.to_string())
7997                    .collect::<Vec<String>>()
7998                    .join(",")
7999                    .to_string(),
8000            )]),
8001        };
8002    }
8003    if let Some(ref local_var_str) = email__regex {
8004        local_var_req_builder = match "multi" {
8005            "multi" => local_var_req_builder.query(
8006                &local_var_str
8007                    .into_iter()
8008                    .map(|p| ("email__regex".to_owned(), p.to_string()))
8009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8010            ),
8011            _ => local_var_req_builder.query(&[(
8012                "email__regex",
8013                &local_var_str
8014                    .into_iter()
8015                    .map(|p| p.to_string())
8016                    .collect::<Vec<String>>()
8017                    .join(",")
8018                    .to_string(),
8019            )]),
8020        };
8021    }
8022    if let Some(ref local_var_str) = first_name {
8023        local_var_req_builder = match "multi" {
8024            "multi" => local_var_req_builder.query(
8025                &local_var_str
8026                    .into_iter()
8027                    .map(|p| ("first_name".to_owned(), p.to_string()))
8028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8029            ),
8030            _ => local_var_req_builder.query(&[(
8031                "first_name",
8032                &local_var_str
8033                    .into_iter()
8034                    .map(|p| p.to_string())
8035                    .collect::<Vec<String>>()
8036                    .join(",")
8037                    .to_string(),
8038            )]),
8039        };
8040    }
8041    if let Some(ref local_var_str) = first_name__empty {
8042        local_var_req_builder =
8043            local_var_req_builder.query(&[("first_name__empty", &local_var_str.to_string())]);
8044    }
8045    if let Some(ref local_var_str) = first_name__ic {
8046        local_var_req_builder = match "multi" {
8047            "multi" => local_var_req_builder.query(
8048                &local_var_str
8049                    .into_iter()
8050                    .map(|p| ("first_name__ic".to_owned(), p.to_string()))
8051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8052            ),
8053            _ => local_var_req_builder.query(&[(
8054                "first_name__ic",
8055                &local_var_str
8056                    .into_iter()
8057                    .map(|p| p.to_string())
8058                    .collect::<Vec<String>>()
8059                    .join(",")
8060                    .to_string(),
8061            )]),
8062        };
8063    }
8064    if let Some(ref local_var_str) = first_name__ie {
8065        local_var_req_builder = match "multi" {
8066            "multi" => local_var_req_builder.query(
8067                &local_var_str
8068                    .into_iter()
8069                    .map(|p| ("first_name__ie".to_owned(), p.to_string()))
8070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8071            ),
8072            _ => local_var_req_builder.query(&[(
8073                "first_name__ie",
8074                &local_var_str
8075                    .into_iter()
8076                    .map(|p| p.to_string())
8077                    .collect::<Vec<String>>()
8078                    .join(",")
8079                    .to_string(),
8080            )]),
8081        };
8082    }
8083    if let Some(ref local_var_str) = first_name__iew {
8084        local_var_req_builder = match "multi" {
8085            "multi" => local_var_req_builder.query(
8086                &local_var_str
8087                    .into_iter()
8088                    .map(|p| ("first_name__iew".to_owned(), p.to_string()))
8089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8090            ),
8091            _ => local_var_req_builder.query(&[(
8092                "first_name__iew",
8093                &local_var_str
8094                    .into_iter()
8095                    .map(|p| p.to_string())
8096                    .collect::<Vec<String>>()
8097                    .join(",")
8098                    .to_string(),
8099            )]),
8100        };
8101    }
8102    if let Some(ref local_var_str) = first_name__iregex {
8103        local_var_req_builder = match "multi" {
8104            "multi" => local_var_req_builder.query(
8105                &local_var_str
8106                    .into_iter()
8107                    .map(|p| ("first_name__iregex".to_owned(), p.to_string()))
8108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8109            ),
8110            _ => local_var_req_builder.query(&[(
8111                "first_name__iregex",
8112                &local_var_str
8113                    .into_iter()
8114                    .map(|p| p.to_string())
8115                    .collect::<Vec<String>>()
8116                    .join(",")
8117                    .to_string(),
8118            )]),
8119        };
8120    }
8121    if let Some(ref local_var_str) = first_name__isw {
8122        local_var_req_builder = match "multi" {
8123            "multi" => local_var_req_builder.query(
8124                &local_var_str
8125                    .into_iter()
8126                    .map(|p| ("first_name__isw".to_owned(), p.to_string()))
8127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8128            ),
8129            _ => local_var_req_builder.query(&[(
8130                "first_name__isw",
8131                &local_var_str
8132                    .into_iter()
8133                    .map(|p| p.to_string())
8134                    .collect::<Vec<String>>()
8135                    .join(",")
8136                    .to_string(),
8137            )]),
8138        };
8139    }
8140    if let Some(ref local_var_str) = first_name__n {
8141        local_var_req_builder = match "multi" {
8142            "multi" => local_var_req_builder.query(
8143                &local_var_str
8144                    .into_iter()
8145                    .map(|p| ("first_name__n".to_owned(), p.to_string()))
8146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8147            ),
8148            _ => local_var_req_builder.query(&[(
8149                "first_name__n",
8150                &local_var_str
8151                    .into_iter()
8152                    .map(|p| p.to_string())
8153                    .collect::<Vec<String>>()
8154                    .join(",")
8155                    .to_string(),
8156            )]),
8157        };
8158    }
8159    if let Some(ref local_var_str) = first_name__nic {
8160        local_var_req_builder = match "multi" {
8161            "multi" => local_var_req_builder.query(
8162                &local_var_str
8163                    .into_iter()
8164                    .map(|p| ("first_name__nic".to_owned(), p.to_string()))
8165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8166            ),
8167            _ => local_var_req_builder.query(&[(
8168                "first_name__nic",
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| p.to_string())
8172                    .collect::<Vec<String>>()
8173                    .join(",")
8174                    .to_string(),
8175            )]),
8176        };
8177    }
8178    if let Some(ref local_var_str) = first_name__nie {
8179        local_var_req_builder = match "multi" {
8180            "multi" => local_var_req_builder.query(
8181                &local_var_str
8182                    .into_iter()
8183                    .map(|p| ("first_name__nie".to_owned(), p.to_string()))
8184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8185            ),
8186            _ => local_var_req_builder.query(&[(
8187                "first_name__nie",
8188                &local_var_str
8189                    .into_iter()
8190                    .map(|p| p.to_string())
8191                    .collect::<Vec<String>>()
8192                    .join(",")
8193                    .to_string(),
8194            )]),
8195        };
8196    }
8197    if let Some(ref local_var_str) = first_name__niew {
8198        local_var_req_builder = match "multi" {
8199            "multi" => local_var_req_builder.query(
8200                &local_var_str
8201                    .into_iter()
8202                    .map(|p| ("first_name__niew".to_owned(), p.to_string()))
8203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8204            ),
8205            _ => local_var_req_builder.query(&[(
8206                "first_name__niew",
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| p.to_string())
8210                    .collect::<Vec<String>>()
8211                    .join(",")
8212                    .to_string(),
8213            )]),
8214        };
8215    }
8216    if let Some(ref local_var_str) = first_name__nisw {
8217        local_var_req_builder = match "multi" {
8218            "multi" => local_var_req_builder.query(
8219                &local_var_str
8220                    .into_iter()
8221                    .map(|p| ("first_name__nisw".to_owned(), p.to_string()))
8222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8223            ),
8224            _ => local_var_req_builder.query(&[(
8225                "first_name__nisw",
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| p.to_string())
8229                    .collect::<Vec<String>>()
8230                    .join(",")
8231                    .to_string(),
8232            )]),
8233        };
8234    }
8235    if let Some(ref local_var_str) = first_name__regex {
8236        local_var_req_builder = match "multi" {
8237            "multi" => local_var_req_builder.query(
8238                &local_var_str
8239                    .into_iter()
8240                    .map(|p| ("first_name__regex".to_owned(), p.to_string()))
8241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8242            ),
8243            _ => local_var_req_builder.query(&[(
8244                "first_name__regex",
8245                &local_var_str
8246                    .into_iter()
8247                    .map(|p| p.to_string())
8248                    .collect::<Vec<String>>()
8249                    .join(",")
8250                    .to_string(),
8251            )]),
8252        };
8253    }
8254    if let Some(ref local_var_str) = group {
8255        local_var_req_builder = match "multi" {
8256            "multi" => local_var_req_builder.query(
8257                &local_var_str
8258                    .into_iter()
8259                    .map(|p| ("group".to_owned(), p.to_string()))
8260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8261            ),
8262            _ => local_var_req_builder.query(&[(
8263                "group",
8264                &local_var_str
8265                    .into_iter()
8266                    .map(|p| p.to_string())
8267                    .collect::<Vec<String>>()
8268                    .join(",")
8269                    .to_string(),
8270            )]),
8271        };
8272    }
8273    if let Some(ref local_var_str) = group__n {
8274        local_var_req_builder = match "multi" {
8275            "multi" => local_var_req_builder.query(
8276                &local_var_str
8277                    .into_iter()
8278                    .map(|p| ("group__n".to_owned(), p.to_string()))
8279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8280            ),
8281            _ => local_var_req_builder.query(&[(
8282                "group__n",
8283                &local_var_str
8284                    .into_iter()
8285                    .map(|p| p.to_string())
8286                    .collect::<Vec<String>>()
8287                    .join(",")
8288                    .to_string(),
8289            )]),
8290        };
8291    }
8292    if let Some(ref local_var_str) = group_id {
8293        local_var_req_builder = match "multi" {
8294            "multi" => local_var_req_builder.query(
8295                &local_var_str
8296                    .into_iter()
8297                    .map(|p| ("group_id".to_owned(), p.to_string()))
8298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8299            ),
8300            _ => local_var_req_builder.query(&[(
8301                "group_id",
8302                &local_var_str
8303                    .into_iter()
8304                    .map(|p| p.to_string())
8305                    .collect::<Vec<String>>()
8306                    .join(",")
8307                    .to_string(),
8308            )]),
8309        };
8310    }
8311    if let Some(ref local_var_str) = group_id__n {
8312        local_var_req_builder = match "multi" {
8313            "multi" => local_var_req_builder.query(
8314                &local_var_str
8315                    .into_iter()
8316                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
8317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8318            ),
8319            _ => local_var_req_builder.query(&[(
8320                "group_id__n",
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| p.to_string())
8324                    .collect::<Vec<String>>()
8325                    .join(",")
8326                    .to_string(),
8327            )]),
8328        };
8329    }
8330    if let Some(ref local_var_str) = id {
8331        local_var_req_builder = match "multi" {
8332            "multi" => local_var_req_builder.query(
8333                &local_var_str
8334                    .into_iter()
8335                    .map(|p| ("id".to_owned(), p.to_string()))
8336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8337            ),
8338            _ => local_var_req_builder.query(&[(
8339                "id",
8340                &local_var_str
8341                    .into_iter()
8342                    .map(|p| p.to_string())
8343                    .collect::<Vec<String>>()
8344                    .join(",")
8345                    .to_string(),
8346            )]),
8347        };
8348    }
8349    if let Some(ref local_var_str) = id__empty {
8350        local_var_req_builder =
8351            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8352    }
8353    if let Some(ref local_var_str) = id__gt {
8354        local_var_req_builder = match "multi" {
8355            "multi" => local_var_req_builder.query(
8356                &local_var_str
8357                    .into_iter()
8358                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8360            ),
8361            _ => local_var_req_builder.query(&[(
8362                "id__gt",
8363                &local_var_str
8364                    .into_iter()
8365                    .map(|p| p.to_string())
8366                    .collect::<Vec<String>>()
8367                    .join(",")
8368                    .to_string(),
8369            )]),
8370        };
8371    }
8372    if let Some(ref local_var_str) = id__gte {
8373        local_var_req_builder = match "multi" {
8374            "multi" => local_var_req_builder.query(
8375                &local_var_str
8376                    .into_iter()
8377                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8379            ),
8380            _ => local_var_req_builder.query(&[(
8381                "id__gte",
8382                &local_var_str
8383                    .into_iter()
8384                    .map(|p| p.to_string())
8385                    .collect::<Vec<String>>()
8386                    .join(",")
8387                    .to_string(),
8388            )]),
8389        };
8390    }
8391    if let Some(ref local_var_str) = id__lt {
8392        local_var_req_builder = match "multi" {
8393            "multi" => local_var_req_builder.query(
8394                &local_var_str
8395                    .into_iter()
8396                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8398            ),
8399            _ => local_var_req_builder.query(&[(
8400                "id__lt",
8401                &local_var_str
8402                    .into_iter()
8403                    .map(|p| p.to_string())
8404                    .collect::<Vec<String>>()
8405                    .join(",")
8406                    .to_string(),
8407            )]),
8408        };
8409    }
8410    if let Some(ref local_var_str) = id__lte {
8411        local_var_req_builder = match "multi" {
8412            "multi" => local_var_req_builder.query(
8413                &local_var_str
8414                    .into_iter()
8415                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8417            ),
8418            _ => local_var_req_builder.query(&[(
8419                "id__lte",
8420                &local_var_str
8421                    .into_iter()
8422                    .map(|p| p.to_string())
8423                    .collect::<Vec<String>>()
8424                    .join(",")
8425                    .to_string(),
8426            )]),
8427        };
8428    }
8429    if let Some(ref local_var_str) = id__n {
8430        local_var_req_builder = match "multi" {
8431            "multi" => local_var_req_builder.query(
8432                &local_var_str
8433                    .into_iter()
8434                    .map(|p| ("id__n".to_owned(), p.to_string()))
8435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8436            ),
8437            _ => local_var_req_builder.query(&[(
8438                "id__n",
8439                &local_var_str
8440                    .into_iter()
8441                    .map(|p| p.to_string())
8442                    .collect::<Vec<String>>()
8443                    .join(",")
8444                    .to_string(),
8445            )]),
8446        };
8447    }
8448    if let Some(ref local_var_str) = is_active {
8449        local_var_req_builder =
8450            local_var_req_builder.query(&[("is_active", &local_var_str.to_string())]);
8451    }
8452    if let Some(ref local_var_str) = is_superuser {
8453        local_var_req_builder =
8454            local_var_req_builder.query(&[("is_superuser", &local_var_str.to_string())]);
8455    }
8456    if let Some(ref local_var_str) = last_login {
8457        local_var_req_builder = match "multi" {
8458            "multi" => local_var_req_builder.query(
8459                &local_var_str
8460                    .into_iter()
8461                    .map(|p| ("last_login".to_owned(), p.to_string()))
8462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8463            ),
8464            _ => local_var_req_builder.query(&[(
8465                "last_login",
8466                &local_var_str
8467                    .into_iter()
8468                    .map(|p| p.to_string())
8469                    .collect::<Vec<String>>()
8470                    .join(",")
8471                    .to_string(),
8472            )]),
8473        };
8474    }
8475    if let Some(ref local_var_str) = last_login__empty {
8476        local_var_req_builder =
8477            local_var_req_builder.query(&[("last_login__empty", &local_var_str.to_string())]);
8478    }
8479    if let Some(ref local_var_str) = last_login__gt {
8480        local_var_req_builder = match "multi" {
8481            "multi" => local_var_req_builder.query(
8482                &local_var_str
8483                    .into_iter()
8484                    .map(|p| ("last_login__gt".to_owned(), p.to_string()))
8485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8486            ),
8487            _ => local_var_req_builder.query(&[(
8488                "last_login__gt",
8489                &local_var_str
8490                    .into_iter()
8491                    .map(|p| p.to_string())
8492                    .collect::<Vec<String>>()
8493                    .join(",")
8494                    .to_string(),
8495            )]),
8496        };
8497    }
8498    if let Some(ref local_var_str) = last_login__gte {
8499        local_var_req_builder = match "multi" {
8500            "multi" => local_var_req_builder.query(
8501                &local_var_str
8502                    .into_iter()
8503                    .map(|p| ("last_login__gte".to_owned(), p.to_string()))
8504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8505            ),
8506            _ => local_var_req_builder.query(&[(
8507                "last_login__gte",
8508                &local_var_str
8509                    .into_iter()
8510                    .map(|p| p.to_string())
8511                    .collect::<Vec<String>>()
8512                    .join(",")
8513                    .to_string(),
8514            )]),
8515        };
8516    }
8517    if let Some(ref local_var_str) = last_login__lt {
8518        local_var_req_builder = match "multi" {
8519            "multi" => local_var_req_builder.query(
8520                &local_var_str
8521                    .into_iter()
8522                    .map(|p| ("last_login__lt".to_owned(), p.to_string()))
8523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8524            ),
8525            _ => local_var_req_builder.query(&[(
8526                "last_login__lt",
8527                &local_var_str
8528                    .into_iter()
8529                    .map(|p| p.to_string())
8530                    .collect::<Vec<String>>()
8531                    .join(",")
8532                    .to_string(),
8533            )]),
8534        };
8535    }
8536    if let Some(ref local_var_str) = last_login__lte {
8537        local_var_req_builder = match "multi" {
8538            "multi" => local_var_req_builder.query(
8539                &local_var_str
8540                    .into_iter()
8541                    .map(|p| ("last_login__lte".to_owned(), p.to_string()))
8542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8543            ),
8544            _ => local_var_req_builder.query(&[(
8545                "last_login__lte",
8546                &local_var_str
8547                    .into_iter()
8548                    .map(|p| p.to_string())
8549                    .collect::<Vec<String>>()
8550                    .join(",")
8551                    .to_string(),
8552            )]),
8553        };
8554    }
8555    if let Some(ref local_var_str) = last_login__n {
8556        local_var_req_builder = match "multi" {
8557            "multi" => local_var_req_builder.query(
8558                &local_var_str
8559                    .into_iter()
8560                    .map(|p| ("last_login__n".to_owned(), p.to_string()))
8561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8562            ),
8563            _ => local_var_req_builder.query(&[(
8564                "last_login__n",
8565                &local_var_str
8566                    .into_iter()
8567                    .map(|p| p.to_string())
8568                    .collect::<Vec<String>>()
8569                    .join(",")
8570                    .to_string(),
8571            )]),
8572        };
8573    }
8574    if let Some(ref local_var_str) = last_name {
8575        local_var_req_builder = match "multi" {
8576            "multi" => local_var_req_builder.query(
8577                &local_var_str
8578                    .into_iter()
8579                    .map(|p| ("last_name".to_owned(), p.to_string()))
8580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8581            ),
8582            _ => local_var_req_builder.query(&[(
8583                "last_name",
8584                &local_var_str
8585                    .into_iter()
8586                    .map(|p| p.to_string())
8587                    .collect::<Vec<String>>()
8588                    .join(",")
8589                    .to_string(),
8590            )]),
8591        };
8592    }
8593    if let Some(ref local_var_str) = last_name__empty {
8594        local_var_req_builder =
8595            local_var_req_builder.query(&[("last_name__empty", &local_var_str.to_string())]);
8596    }
8597    if let Some(ref local_var_str) = last_name__ic {
8598        local_var_req_builder = match "multi" {
8599            "multi" => local_var_req_builder.query(
8600                &local_var_str
8601                    .into_iter()
8602                    .map(|p| ("last_name__ic".to_owned(), p.to_string()))
8603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8604            ),
8605            _ => local_var_req_builder.query(&[(
8606                "last_name__ic",
8607                &local_var_str
8608                    .into_iter()
8609                    .map(|p| p.to_string())
8610                    .collect::<Vec<String>>()
8611                    .join(",")
8612                    .to_string(),
8613            )]),
8614        };
8615    }
8616    if let Some(ref local_var_str) = last_name__ie {
8617        local_var_req_builder = match "multi" {
8618            "multi" => local_var_req_builder.query(
8619                &local_var_str
8620                    .into_iter()
8621                    .map(|p| ("last_name__ie".to_owned(), p.to_string()))
8622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8623            ),
8624            _ => local_var_req_builder.query(&[(
8625                "last_name__ie",
8626                &local_var_str
8627                    .into_iter()
8628                    .map(|p| p.to_string())
8629                    .collect::<Vec<String>>()
8630                    .join(",")
8631                    .to_string(),
8632            )]),
8633        };
8634    }
8635    if let Some(ref local_var_str) = last_name__iew {
8636        local_var_req_builder = match "multi" {
8637            "multi" => local_var_req_builder.query(
8638                &local_var_str
8639                    .into_iter()
8640                    .map(|p| ("last_name__iew".to_owned(), p.to_string()))
8641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8642            ),
8643            _ => local_var_req_builder.query(&[(
8644                "last_name__iew",
8645                &local_var_str
8646                    .into_iter()
8647                    .map(|p| p.to_string())
8648                    .collect::<Vec<String>>()
8649                    .join(",")
8650                    .to_string(),
8651            )]),
8652        };
8653    }
8654    if let Some(ref local_var_str) = last_name__iregex {
8655        local_var_req_builder = match "multi" {
8656            "multi" => local_var_req_builder.query(
8657                &local_var_str
8658                    .into_iter()
8659                    .map(|p| ("last_name__iregex".to_owned(), p.to_string()))
8660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8661            ),
8662            _ => local_var_req_builder.query(&[(
8663                "last_name__iregex",
8664                &local_var_str
8665                    .into_iter()
8666                    .map(|p| p.to_string())
8667                    .collect::<Vec<String>>()
8668                    .join(",")
8669                    .to_string(),
8670            )]),
8671        };
8672    }
8673    if let Some(ref local_var_str) = last_name__isw {
8674        local_var_req_builder = match "multi" {
8675            "multi" => local_var_req_builder.query(
8676                &local_var_str
8677                    .into_iter()
8678                    .map(|p| ("last_name__isw".to_owned(), p.to_string()))
8679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8680            ),
8681            _ => local_var_req_builder.query(&[(
8682                "last_name__isw",
8683                &local_var_str
8684                    .into_iter()
8685                    .map(|p| p.to_string())
8686                    .collect::<Vec<String>>()
8687                    .join(",")
8688                    .to_string(),
8689            )]),
8690        };
8691    }
8692    if let Some(ref local_var_str) = last_name__n {
8693        local_var_req_builder = match "multi" {
8694            "multi" => local_var_req_builder.query(
8695                &local_var_str
8696                    .into_iter()
8697                    .map(|p| ("last_name__n".to_owned(), p.to_string()))
8698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8699            ),
8700            _ => local_var_req_builder.query(&[(
8701                "last_name__n",
8702                &local_var_str
8703                    .into_iter()
8704                    .map(|p| p.to_string())
8705                    .collect::<Vec<String>>()
8706                    .join(",")
8707                    .to_string(),
8708            )]),
8709        };
8710    }
8711    if let Some(ref local_var_str) = last_name__nic {
8712        local_var_req_builder = match "multi" {
8713            "multi" => local_var_req_builder.query(
8714                &local_var_str
8715                    .into_iter()
8716                    .map(|p| ("last_name__nic".to_owned(), p.to_string()))
8717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8718            ),
8719            _ => local_var_req_builder.query(&[(
8720                "last_name__nic",
8721                &local_var_str
8722                    .into_iter()
8723                    .map(|p| p.to_string())
8724                    .collect::<Vec<String>>()
8725                    .join(",")
8726                    .to_string(),
8727            )]),
8728        };
8729    }
8730    if let Some(ref local_var_str) = last_name__nie {
8731        local_var_req_builder = match "multi" {
8732            "multi" => local_var_req_builder.query(
8733                &local_var_str
8734                    .into_iter()
8735                    .map(|p| ("last_name__nie".to_owned(), p.to_string()))
8736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8737            ),
8738            _ => local_var_req_builder.query(&[(
8739                "last_name__nie",
8740                &local_var_str
8741                    .into_iter()
8742                    .map(|p| p.to_string())
8743                    .collect::<Vec<String>>()
8744                    .join(",")
8745                    .to_string(),
8746            )]),
8747        };
8748    }
8749    if let Some(ref local_var_str) = last_name__niew {
8750        local_var_req_builder = match "multi" {
8751            "multi" => local_var_req_builder.query(
8752                &local_var_str
8753                    .into_iter()
8754                    .map(|p| ("last_name__niew".to_owned(), p.to_string()))
8755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8756            ),
8757            _ => local_var_req_builder.query(&[(
8758                "last_name__niew",
8759                &local_var_str
8760                    .into_iter()
8761                    .map(|p| p.to_string())
8762                    .collect::<Vec<String>>()
8763                    .join(",")
8764                    .to_string(),
8765            )]),
8766        };
8767    }
8768    if let Some(ref local_var_str) = last_name__nisw {
8769        local_var_req_builder = match "multi" {
8770            "multi" => local_var_req_builder.query(
8771                &local_var_str
8772                    .into_iter()
8773                    .map(|p| ("last_name__nisw".to_owned(), p.to_string()))
8774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8775            ),
8776            _ => local_var_req_builder.query(&[(
8777                "last_name__nisw",
8778                &local_var_str
8779                    .into_iter()
8780                    .map(|p| p.to_string())
8781                    .collect::<Vec<String>>()
8782                    .join(",")
8783                    .to_string(),
8784            )]),
8785        };
8786    }
8787    if let Some(ref local_var_str) = last_name__regex {
8788        local_var_req_builder = match "multi" {
8789            "multi" => local_var_req_builder.query(
8790                &local_var_str
8791                    .into_iter()
8792                    .map(|p| ("last_name__regex".to_owned(), p.to_string()))
8793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8794            ),
8795            _ => local_var_req_builder.query(&[(
8796                "last_name__regex",
8797                &local_var_str
8798                    .into_iter()
8799                    .map(|p| p.to_string())
8800                    .collect::<Vec<String>>()
8801                    .join(",")
8802                    .to_string(),
8803            )]),
8804        };
8805    }
8806    if let Some(ref local_var_str) = limit {
8807        local_var_req_builder =
8808            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8809    }
8810    if let Some(ref local_var_str) = notification_group_id {
8811        local_var_req_builder = match "multi" {
8812            "multi" => local_var_req_builder.query(
8813                &local_var_str
8814                    .into_iter()
8815                    .map(|p| ("notification_group_id".to_owned(), p.to_string()))
8816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8817            ),
8818            _ => local_var_req_builder.query(&[(
8819                "notification_group_id",
8820                &local_var_str
8821                    .into_iter()
8822                    .map(|p| p.to_string())
8823                    .collect::<Vec<String>>()
8824                    .join(",")
8825                    .to_string(),
8826            )]),
8827        };
8828    }
8829    if let Some(ref local_var_str) = notification_group_id__n {
8830        local_var_req_builder = match "multi" {
8831            "multi" => local_var_req_builder.query(
8832                &local_var_str
8833                    .into_iter()
8834                    .map(|p| ("notification_group_id__n".to_owned(), p.to_string()))
8835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8836            ),
8837            _ => local_var_req_builder.query(&[(
8838                "notification_group_id__n",
8839                &local_var_str
8840                    .into_iter()
8841                    .map(|p| p.to_string())
8842                    .collect::<Vec<String>>()
8843                    .join(",")
8844                    .to_string(),
8845            )]),
8846        };
8847    }
8848    if let Some(ref local_var_str) = offset {
8849        local_var_req_builder =
8850            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8851    }
8852    if let Some(ref local_var_str) = ordering {
8853        local_var_req_builder =
8854            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
8855    }
8856    if let Some(ref local_var_str) = owner {
8857        local_var_req_builder = match "multi" {
8858            "multi" => local_var_req_builder.query(
8859                &local_var_str
8860                    .into_iter()
8861                    .map(|p| ("owner".to_owned(), p.to_string()))
8862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8863            ),
8864            _ => local_var_req_builder.query(&[(
8865                "owner",
8866                &local_var_str
8867                    .into_iter()
8868                    .map(|p| p.to_string())
8869                    .collect::<Vec<String>>()
8870                    .join(",")
8871                    .to_string(),
8872            )]),
8873        };
8874    }
8875    if let Some(ref local_var_str) = owner__n {
8876        local_var_req_builder = match "multi" {
8877            "multi" => local_var_req_builder.query(
8878                &local_var_str
8879                    .into_iter()
8880                    .map(|p| ("owner__n".to_owned(), p.to_string()))
8881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8882            ),
8883            _ => local_var_req_builder.query(&[(
8884                "owner__n",
8885                &local_var_str
8886                    .into_iter()
8887                    .map(|p| p.to_string())
8888                    .collect::<Vec<String>>()
8889                    .join(",")
8890                    .to_string(),
8891            )]),
8892        };
8893    }
8894    if let Some(ref local_var_str) = owner_id {
8895        local_var_req_builder = match "multi" {
8896            "multi" => local_var_req_builder.query(
8897                &local_var_str
8898                    .into_iter()
8899                    .map(|p| ("owner_id".to_owned(), p.to_string()))
8900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8901            ),
8902            _ => local_var_req_builder.query(&[(
8903                "owner_id",
8904                &local_var_str
8905                    .into_iter()
8906                    .map(|p| p.to_string())
8907                    .collect::<Vec<String>>()
8908                    .join(",")
8909                    .to_string(),
8910            )]),
8911        };
8912    }
8913    if let Some(ref local_var_str) = owner_id__n {
8914        local_var_req_builder = match "multi" {
8915            "multi" => local_var_req_builder.query(
8916                &local_var_str
8917                    .into_iter()
8918                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
8919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8920            ),
8921            _ => local_var_req_builder.query(&[(
8922                "owner_id__n",
8923                &local_var_str
8924                    .into_iter()
8925                    .map(|p| p.to_string())
8926                    .collect::<Vec<String>>()
8927                    .join(",")
8928                    .to_string(),
8929            )]),
8930        };
8931    }
8932    if let Some(ref local_var_str) = permission_id {
8933        local_var_req_builder = match "multi" {
8934            "multi" => local_var_req_builder.query(
8935                &local_var_str
8936                    .into_iter()
8937                    .map(|p| ("permission_id".to_owned(), p.to_string()))
8938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8939            ),
8940            _ => local_var_req_builder.query(&[(
8941                "permission_id",
8942                &local_var_str
8943                    .into_iter()
8944                    .map(|p| p.to_string())
8945                    .collect::<Vec<String>>()
8946                    .join(",")
8947                    .to_string(),
8948            )]),
8949        };
8950    }
8951    if let Some(ref local_var_str) = permission_id__n {
8952        local_var_req_builder = match "multi" {
8953            "multi" => local_var_req_builder.query(
8954                &local_var_str
8955                    .into_iter()
8956                    .map(|p| ("permission_id__n".to_owned(), p.to_string()))
8957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8958            ),
8959            _ => local_var_req_builder.query(&[(
8960                "permission_id__n",
8961                &local_var_str
8962                    .into_iter()
8963                    .map(|p| p.to_string())
8964                    .collect::<Vec<String>>()
8965                    .join(",")
8966                    .to_string(),
8967            )]),
8968        };
8969    }
8970    if let Some(ref local_var_str) = q {
8971        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8972    }
8973    if let Some(ref local_var_str) = start {
8974        local_var_req_builder =
8975            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
8976    }
8977    if let Some(ref local_var_str) = username {
8978        local_var_req_builder = match "multi" {
8979            "multi" => local_var_req_builder.query(
8980                &local_var_str
8981                    .into_iter()
8982                    .map(|p| ("username".to_owned(), p.to_string()))
8983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8984            ),
8985            _ => local_var_req_builder.query(&[(
8986                "username",
8987                &local_var_str
8988                    .into_iter()
8989                    .map(|p| p.to_string())
8990                    .collect::<Vec<String>>()
8991                    .join(",")
8992                    .to_string(),
8993            )]),
8994        };
8995    }
8996    if let Some(ref local_var_str) = username__empty {
8997        local_var_req_builder =
8998            local_var_req_builder.query(&[("username__empty", &local_var_str.to_string())]);
8999    }
9000    if let Some(ref local_var_str) = username__ic {
9001        local_var_req_builder = match "multi" {
9002            "multi" => local_var_req_builder.query(
9003                &local_var_str
9004                    .into_iter()
9005                    .map(|p| ("username__ic".to_owned(), p.to_string()))
9006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9007            ),
9008            _ => local_var_req_builder.query(&[(
9009                "username__ic",
9010                &local_var_str
9011                    .into_iter()
9012                    .map(|p| p.to_string())
9013                    .collect::<Vec<String>>()
9014                    .join(",")
9015                    .to_string(),
9016            )]),
9017        };
9018    }
9019    if let Some(ref local_var_str) = username__ie {
9020        local_var_req_builder = match "multi" {
9021            "multi" => local_var_req_builder.query(
9022                &local_var_str
9023                    .into_iter()
9024                    .map(|p| ("username__ie".to_owned(), p.to_string()))
9025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9026            ),
9027            _ => local_var_req_builder.query(&[(
9028                "username__ie",
9029                &local_var_str
9030                    .into_iter()
9031                    .map(|p| p.to_string())
9032                    .collect::<Vec<String>>()
9033                    .join(",")
9034                    .to_string(),
9035            )]),
9036        };
9037    }
9038    if let Some(ref local_var_str) = username__iew {
9039        local_var_req_builder = match "multi" {
9040            "multi" => local_var_req_builder.query(
9041                &local_var_str
9042                    .into_iter()
9043                    .map(|p| ("username__iew".to_owned(), p.to_string()))
9044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9045            ),
9046            _ => local_var_req_builder.query(&[(
9047                "username__iew",
9048                &local_var_str
9049                    .into_iter()
9050                    .map(|p| p.to_string())
9051                    .collect::<Vec<String>>()
9052                    .join(",")
9053                    .to_string(),
9054            )]),
9055        };
9056    }
9057    if let Some(ref local_var_str) = username__iregex {
9058        local_var_req_builder = match "multi" {
9059            "multi" => local_var_req_builder.query(
9060                &local_var_str
9061                    .into_iter()
9062                    .map(|p| ("username__iregex".to_owned(), p.to_string()))
9063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9064            ),
9065            _ => local_var_req_builder.query(&[(
9066                "username__iregex",
9067                &local_var_str
9068                    .into_iter()
9069                    .map(|p| p.to_string())
9070                    .collect::<Vec<String>>()
9071                    .join(",")
9072                    .to_string(),
9073            )]),
9074        };
9075    }
9076    if let Some(ref local_var_str) = username__isw {
9077        local_var_req_builder = match "multi" {
9078            "multi" => local_var_req_builder.query(
9079                &local_var_str
9080                    .into_iter()
9081                    .map(|p| ("username__isw".to_owned(), p.to_string()))
9082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9083            ),
9084            _ => local_var_req_builder.query(&[(
9085                "username__isw",
9086                &local_var_str
9087                    .into_iter()
9088                    .map(|p| p.to_string())
9089                    .collect::<Vec<String>>()
9090                    .join(",")
9091                    .to_string(),
9092            )]),
9093        };
9094    }
9095    if let Some(ref local_var_str) = username__n {
9096        local_var_req_builder = match "multi" {
9097            "multi" => local_var_req_builder.query(
9098                &local_var_str
9099                    .into_iter()
9100                    .map(|p| ("username__n".to_owned(), p.to_string()))
9101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9102            ),
9103            _ => local_var_req_builder.query(&[(
9104                "username__n",
9105                &local_var_str
9106                    .into_iter()
9107                    .map(|p| p.to_string())
9108                    .collect::<Vec<String>>()
9109                    .join(",")
9110                    .to_string(),
9111            )]),
9112        };
9113    }
9114    if let Some(ref local_var_str) = username__nic {
9115        local_var_req_builder = match "multi" {
9116            "multi" => local_var_req_builder.query(
9117                &local_var_str
9118                    .into_iter()
9119                    .map(|p| ("username__nic".to_owned(), p.to_string()))
9120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9121            ),
9122            _ => local_var_req_builder.query(&[(
9123                "username__nic",
9124                &local_var_str
9125                    .into_iter()
9126                    .map(|p| p.to_string())
9127                    .collect::<Vec<String>>()
9128                    .join(",")
9129                    .to_string(),
9130            )]),
9131        };
9132    }
9133    if let Some(ref local_var_str) = username__nie {
9134        local_var_req_builder = match "multi" {
9135            "multi" => local_var_req_builder.query(
9136                &local_var_str
9137                    .into_iter()
9138                    .map(|p| ("username__nie".to_owned(), p.to_string()))
9139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9140            ),
9141            _ => local_var_req_builder.query(&[(
9142                "username__nie",
9143                &local_var_str
9144                    .into_iter()
9145                    .map(|p| p.to_string())
9146                    .collect::<Vec<String>>()
9147                    .join(",")
9148                    .to_string(),
9149            )]),
9150        };
9151    }
9152    if let Some(ref local_var_str) = username__niew {
9153        local_var_req_builder = match "multi" {
9154            "multi" => local_var_req_builder.query(
9155                &local_var_str
9156                    .into_iter()
9157                    .map(|p| ("username__niew".to_owned(), p.to_string()))
9158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9159            ),
9160            _ => local_var_req_builder.query(&[(
9161                "username__niew",
9162                &local_var_str
9163                    .into_iter()
9164                    .map(|p| p.to_string())
9165                    .collect::<Vec<String>>()
9166                    .join(",")
9167                    .to_string(),
9168            )]),
9169        };
9170    }
9171    if let Some(ref local_var_str) = username__nisw {
9172        local_var_req_builder = match "multi" {
9173            "multi" => local_var_req_builder.query(
9174                &local_var_str
9175                    .into_iter()
9176                    .map(|p| ("username__nisw".to_owned(), p.to_string()))
9177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9178            ),
9179            _ => local_var_req_builder.query(&[(
9180                "username__nisw",
9181                &local_var_str
9182                    .into_iter()
9183                    .map(|p| p.to_string())
9184                    .collect::<Vec<String>>()
9185                    .join(",")
9186                    .to_string(),
9187            )]),
9188        };
9189    }
9190    if let Some(ref local_var_str) = username__regex {
9191        local_var_req_builder = match "multi" {
9192            "multi" => local_var_req_builder.query(
9193                &local_var_str
9194                    .into_iter()
9195                    .map(|p| ("username__regex".to_owned(), p.to_string()))
9196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9197            ),
9198            _ => local_var_req_builder.query(&[(
9199                "username__regex",
9200                &local_var_str
9201                    .into_iter()
9202                    .map(|p| p.to_string())
9203                    .collect::<Vec<String>>()
9204                    .join(",")
9205                    .to_string(),
9206            )]),
9207        };
9208    }
9209    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9210        local_var_req_builder =
9211            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9212    }
9213    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9214        let local_var_key = local_var_apikey.key.clone();
9215        let local_var_value = match local_var_apikey.prefix {
9216            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9217            None => local_var_key,
9218        };
9219        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9220    };
9221
9222    let local_var_req = local_var_req_builder.build()?;
9223    let local_var_resp = local_var_client.execute(local_var_req).await?;
9224
9225    let local_var_status = local_var_resp.status();
9226    let local_var_content = local_var_resp.text().await?;
9227
9228    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9229        serde_json::from_str(&local_var_content).map_err(Error::from)
9230    } else {
9231        let local_var_entity: Option<UsersUsersListError> =
9232            serde_json::from_str(&local_var_content).ok();
9233        let local_var_error = ResponseContent {
9234            status: local_var_status,
9235            content: local_var_content,
9236            entity: local_var_entity,
9237        };
9238        Err(Error::ResponseError(local_var_error))
9239    }
9240}
9241
9242/// Patch a user object.
9243pub async fn users_users_partial_update(
9244    configuration: &configuration::Configuration,
9245    id: i32,
9246    patched_user_request: Option<crate::models::PatchedUserRequest>,
9247) -> Result<crate::models::User, Error<UsersUsersPartialUpdateError>> {
9248    let local_var_configuration = configuration;
9249
9250    let local_var_client = &local_var_configuration.client;
9251
9252    let local_var_uri_str = format!(
9253        "{}/api/users/users/{id}/",
9254        local_var_configuration.base_path,
9255        id = id
9256    );
9257    let mut local_var_req_builder =
9258        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9259
9260    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9261        local_var_req_builder =
9262            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9263    }
9264    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9265        let local_var_key = local_var_apikey.key.clone();
9266        let local_var_value = match local_var_apikey.prefix {
9267            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9268            None => local_var_key,
9269        };
9270        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9271    };
9272    local_var_req_builder = local_var_req_builder.json(&patched_user_request);
9273
9274    let local_var_req = local_var_req_builder.build()?;
9275    let local_var_resp = local_var_client.execute(local_var_req).await?;
9276
9277    let local_var_status = local_var_resp.status();
9278    let local_var_content = local_var_resp.text().await?;
9279
9280    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9281        serde_json::from_str(&local_var_content).map_err(Error::from)
9282    } else {
9283        let local_var_entity: Option<UsersUsersPartialUpdateError> =
9284            serde_json::from_str(&local_var_content).ok();
9285        let local_var_error = ResponseContent {
9286            status: local_var_status,
9287            content: local_var_content,
9288            entity: local_var_entity,
9289        };
9290        Err(Error::ResponseError(local_var_error))
9291    }
9292}
9293
9294/// Get a user object.
9295pub async fn users_users_retrieve(
9296    configuration: &configuration::Configuration,
9297    id: i32,
9298) -> Result<crate::models::User, Error<UsersUsersRetrieveError>> {
9299    let local_var_configuration = configuration;
9300
9301    let local_var_client = &local_var_configuration.client;
9302
9303    let local_var_uri_str = format!(
9304        "{}/api/users/users/{id}/",
9305        local_var_configuration.base_path,
9306        id = id
9307    );
9308    let mut local_var_req_builder =
9309        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9310
9311    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9312        local_var_req_builder =
9313            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9314    }
9315    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9316        let local_var_key = local_var_apikey.key.clone();
9317        let local_var_value = match local_var_apikey.prefix {
9318            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9319            None => local_var_key,
9320        };
9321        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9322    };
9323
9324    let local_var_req = local_var_req_builder.build()?;
9325    let local_var_resp = local_var_client.execute(local_var_req).await?;
9326
9327    let local_var_status = local_var_resp.status();
9328    let local_var_content = local_var_resp.text().await?;
9329
9330    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9331        serde_json::from_str(&local_var_content).map_err(Error::from)
9332    } else {
9333        let local_var_entity: Option<UsersUsersRetrieveError> =
9334            serde_json::from_str(&local_var_content).ok();
9335        let local_var_error = ResponseContent {
9336            status: local_var_status,
9337            content: local_var_content,
9338            entity: local_var_entity,
9339        };
9340        Err(Error::ResponseError(local_var_error))
9341    }
9342}
9343
9344/// Put a user object.
9345pub async fn users_users_update(
9346    configuration: &configuration::Configuration,
9347    id: i32,
9348    user_request: crate::models::UserRequest,
9349) -> Result<crate::models::User, Error<UsersUsersUpdateError>> {
9350    let local_var_configuration = configuration;
9351
9352    let local_var_client = &local_var_configuration.client;
9353
9354    let local_var_uri_str = format!(
9355        "{}/api/users/users/{id}/",
9356        local_var_configuration.base_path,
9357        id = id
9358    );
9359    let mut local_var_req_builder =
9360        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9361
9362    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9363        local_var_req_builder =
9364            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9365    }
9366    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9367        let local_var_key = local_var_apikey.key.clone();
9368        let local_var_value = match local_var_apikey.prefix {
9369            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9370            None => local_var_key,
9371        };
9372        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9373    };
9374    local_var_req_builder = local_var_req_builder.json(&user_request);
9375
9376    let local_var_req = local_var_req_builder.build()?;
9377    let local_var_resp = local_var_client.execute(local_var_req).await?;
9378
9379    let local_var_status = local_var_resp.status();
9380    let local_var_content = local_var_resp.text().await?;
9381
9382    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9383        serde_json::from_str(&local_var_content).map_err(Error::from)
9384    } else {
9385        let local_var_entity: Option<UsersUsersUpdateError> =
9386            serde_json::from_str(&local_var_content).ok();
9387        let local_var_error = ResponseContent {
9388            status: local_var_status,
9389            content: local_var_content,
9390            entity: local_var_entity,
9391        };
9392        Err(Error::ResponseError(local_var_error))
9393    }
9394}
netbox_openapi/apis/users_api.rs

netbox_openapi/apis/
users_api.rs
