nautobot_openapi/apis/
users_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`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_permissions_bulk_destroy`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum UsersPermissionsBulkDestroyError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`users_permissions_bulk_partial_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum UsersPermissionsBulkPartialUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`users_permissions_bulk_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum UsersPermissionsBulkUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`users_permissions_create`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum UsersPermissionsCreateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`users_permissions_destroy`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum UsersPermissionsDestroyError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`users_permissions_list`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum UsersPermissionsListError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`users_permissions_partial_update`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum UsersPermissionsPartialUpdateError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`users_permissions_retrieve`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum UsersPermissionsRetrieveError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`users_permissions_update`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum UsersPermissionsUpdateError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`users_tokens_bulk_destroy`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum UsersTokensBulkDestroyError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`users_tokens_bulk_partial_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum UsersTokensBulkPartialUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`users_tokens_bulk_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum UsersTokensBulkUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`users_tokens_create`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum UsersTokensCreateError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`users_tokens_destroy`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum UsersTokensDestroyError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`users_tokens_list`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum UsersTokensListError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`users_tokens_partial_update`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum UsersTokensPartialUpdateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`users_tokens_retrieve`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum UsersTokensRetrieveError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`users_tokens_update`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum UsersTokensUpdateError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`users_users_bulk_destroy`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum UsersUsersBulkDestroyError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`users_users_bulk_partial_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum UsersUsersBulkPartialUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`users_users_bulk_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum UsersUsersBulkUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`users_users_create`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum UsersUsersCreateError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`users_users_destroy`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum UsersUsersDestroyError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`users_users_list`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum UsersUsersListError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`users_users_partial_update`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum UsersUsersPartialUpdateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`users_users_retrieve`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum UsersUsersRetrieveError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`users_users_update`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum UsersUsersUpdateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// Return the config_data for the currently authenticated User.
276pub async fn users_config_retrieve(
277    configuration: &configuration::Configuration,
278    format: Option<&str>,
279    depth: Option<i32>,
280    exclude_m2m: Option<bool>,
281) -> Result<::std::collections::HashMap<String, serde_json::Value>, Error<UsersConfigRetrieveError>>
282{
283    let local_var_configuration = configuration;
284
285    let local_var_client = &local_var_configuration.client;
286
287    let local_var_uri_str = format!("{}/users/config/", local_var_configuration.base_path);
288    let mut local_var_req_builder =
289        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
290
291    if let Some(ref local_var_str) = format {
292        local_var_req_builder =
293            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
294    }
295    if let Some(ref local_var_str) = depth {
296        local_var_req_builder =
297            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
298    }
299    if let Some(ref local_var_str) = exclude_m2m {
300        local_var_req_builder =
301            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
302    }
303    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
304        local_var_req_builder =
305            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
306    }
307    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
308        let local_var_key = local_var_apikey.key.clone();
309        let local_var_value = match local_var_apikey.prefix {
310            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
311            None => local_var_key,
312        };
313        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
314    };
315
316    let local_var_req = local_var_req_builder.build()?;
317    let local_var_resp = local_var_client.execute(local_var_req).await?;
318
319    let local_var_status = local_var_resp.status();
320    let local_var_content = local_var_resp.text().await?;
321
322    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
323        serde_json::from_str(&local_var_content).map_err(Error::from)
324    } else {
325        let local_var_entity: Option<UsersConfigRetrieveError> =
326            serde_json::from_str(&local_var_content).ok();
327        let local_var_error = ResponseContent {
328            status: local_var_status,
329            content: local_var_content,
330            entity: local_var_entity,
331        };
332        Err(Error::ResponseError(local_var_error))
333    }
334}
335
336/// Destroy a list of group objects.
337pub async fn users_groups_bulk_destroy(
338    configuration: &configuration::Configuration,
339    bulk_operation_integer_id_request: Vec<crate::models::BulkOperationIntegerIdRequest>,
340    format: Option<&str>,
341) -> Result<(), Error<UsersGroupsBulkDestroyError>> {
342    let local_var_configuration = configuration;
343
344    let local_var_client = &local_var_configuration.client;
345
346    let local_var_uri_str = format!("{}/users/groups/", local_var_configuration.base_path);
347    let mut local_var_req_builder =
348        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
349
350    if let Some(ref local_var_str) = format {
351        local_var_req_builder =
352            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
353    }
354    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
355        local_var_req_builder =
356            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
357    }
358    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
359        let local_var_key = local_var_apikey.key.clone();
360        let local_var_value = match local_var_apikey.prefix {
361            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
362            None => local_var_key,
363        };
364        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
365    };
366    local_var_req_builder = local_var_req_builder.json(&bulk_operation_integer_id_request);
367
368    let local_var_req = local_var_req_builder.build()?;
369    let local_var_resp = local_var_client.execute(local_var_req).await?;
370
371    let local_var_status = local_var_resp.status();
372    let local_var_content = local_var_resp.text().await?;
373
374    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
375        Ok(())
376    } else {
377        let local_var_entity: Option<UsersGroupsBulkDestroyError> =
378            serde_json::from_str(&local_var_content).ok();
379        let local_var_error = ResponseContent {
380            status: local_var_status,
381            content: local_var_content,
382            entity: local_var_entity,
383        };
384        Err(Error::ResponseError(local_var_error))
385    }
386}
387
388/// Partial update a list of group objects.
389pub async fn users_groups_bulk_partial_update(
390    configuration: &configuration::Configuration,
391    patched_bulk_writable_group_request: Vec<crate::models::PatchedBulkWritableGroupRequest>,
392    format: Option<&str>,
393) -> Result<Vec<crate::models::Group>, Error<UsersGroupsBulkPartialUpdateError>> {
394    let local_var_configuration = configuration;
395
396    let local_var_client = &local_var_configuration.client;
397
398    let local_var_uri_str = format!("{}/users/groups/", local_var_configuration.base_path);
399    let mut local_var_req_builder =
400        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
401
402    if let Some(ref local_var_str) = format {
403        local_var_req_builder =
404            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
405    }
406    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
407        local_var_req_builder =
408            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
409    }
410    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
411        let local_var_key = local_var_apikey.key.clone();
412        let local_var_value = match local_var_apikey.prefix {
413            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
414            None => local_var_key,
415        };
416        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
417    };
418    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_group_request);
419
420    let local_var_req = local_var_req_builder.build()?;
421    let local_var_resp = local_var_client.execute(local_var_req).await?;
422
423    let local_var_status = local_var_resp.status();
424    let local_var_content = local_var_resp.text().await?;
425
426    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
427        serde_json::from_str(&local_var_content).map_err(Error::from)
428    } else {
429        let local_var_entity: Option<UsersGroupsBulkPartialUpdateError> =
430            serde_json::from_str(&local_var_content).ok();
431        let local_var_error = ResponseContent {
432            status: local_var_status,
433            content: local_var_content,
434            entity: local_var_entity,
435        };
436        Err(Error::ResponseError(local_var_error))
437    }
438}
439
440/// Update a list of group objects.
441pub async fn users_groups_bulk_update(
442    configuration: &configuration::Configuration,
443    bulk_writable_group_request: Vec<crate::models::BulkWritableGroupRequest>,
444    format: Option<&str>,
445) -> Result<Vec<crate::models::Group>, Error<UsersGroupsBulkUpdateError>> {
446    let local_var_configuration = configuration;
447
448    let local_var_client = &local_var_configuration.client;
449
450    let local_var_uri_str = format!("{}/users/groups/", local_var_configuration.base_path);
451    let mut local_var_req_builder =
452        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
453
454    if let Some(ref local_var_str) = format {
455        local_var_req_builder =
456            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
457    }
458    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
459        local_var_req_builder =
460            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
461    }
462    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
463        let local_var_key = local_var_apikey.key.clone();
464        let local_var_value = match local_var_apikey.prefix {
465            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
466            None => local_var_key,
467        };
468        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
469    };
470    local_var_req_builder = local_var_req_builder.json(&bulk_writable_group_request);
471
472    let local_var_req = local_var_req_builder.build()?;
473    let local_var_resp = local_var_client.execute(local_var_req).await?;
474
475    let local_var_status = local_var_resp.status();
476    let local_var_content = local_var_resp.text().await?;
477
478    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
479        serde_json::from_str(&local_var_content).map_err(Error::from)
480    } else {
481        let local_var_entity: Option<UsersGroupsBulkUpdateError> =
482            serde_json::from_str(&local_var_content).ok();
483        let local_var_error = ResponseContent {
484            status: local_var_status,
485            content: local_var_content,
486            entity: local_var_entity,
487        };
488        Err(Error::ResponseError(local_var_error))
489    }
490}
491
492/// Create one or more group objects.
493pub async fn users_groups_create(
494    configuration: &configuration::Configuration,
495    group_request: crate::models::GroupRequest,
496    format: Option<&str>,
497) -> Result<crate::models::Group, Error<UsersGroupsCreateError>> {
498    let local_var_configuration = configuration;
499
500    let local_var_client = &local_var_configuration.client;
501
502    let local_var_uri_str = format!("{}/users/groups/", local_var_configuration.base_path);
503    let mut local_var_req_builder =
504        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
505
506    if let Some(ref local_var_str) = format {
507        local_var_req_builder =
508            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
509    }
510    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
511        local_var_req_builder =
512            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
513    }
514    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
515        let local_var_key = local_var_apikey.key.clone();
516        let local_var_value = match local_var_apikey.prefix {
517            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
518            None => local_var_key,
519        };
520        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
521    };
522    local_var_req_builder = local_var_req_builder.json(&group_request);
523
524    let local_var_req = local_var_req_builder.build()?;
525    let local_var_resp = local_var_client.execute(local_var_req).await?;
526
527    let local_var_status = local_var_resp.status();
528    let local_var_content = local_var_resp.text().await?;
529
530    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
531        serde_json::from_str(&local_var_content).map_err(Error::from)
532    } else {
533        let local_var_entity: Option<UsersGroupsCreateError> =
534            serde_json::from_str(&local_var_content).ok();
535        let local_var_error = ResponseContent {
536            status: local_var_status,
537            content: local_var_content,
538            entity: local_var_entity,
539        };
540        Err(Error::ResponseError(local_var_error))
541    }
542}
543
544/// Destroy a group object.
545pub async fn users_groups_destroy(
546    configuration: &configuration::Configuration,
547    id: i32,
548    format: Option<&str>,
549) -> Result<(), Error<UsersGroupsDestroyError>> {
550    let local_var_configuration = configuration;
551
552    let local_var_client = &local_var_configuration.client;
553
554    let local_var_uri_str = format!(
555        "{}/users/groups/{id}/",
556        local_var_configuration.base_path,
557        id = id
558    );
559    let mut local_var_req_builder =
560        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
561
562    if let Some(ref local_var_str) = format {
563        local_var_req_builder =
564            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
565    }
566    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
567        local_var_req_builder =
568            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
569    }
570    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
571        let local_var_key = local_var_apikey.key.clone();
572        let local_var_value = match local_var_apikey.prefix {
573            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
574            None => local_var_key,
575        };
576        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
577    };
578
579    let local_var_req = local_var_req_builder.build()?;
580    let local_var_resp = local_var_client.execute(local_var_req).await?;
581
582    let local_var_status = local_var_resp.status();
583    let local_var_content = local_var_resp.text().await?;
584
585    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
586        Ok(())
587    } else {
588        let local_var_entity: Option<UsersGroupsDestroyError> =
589            serde_json::from_str(&local_var_content).ok();
590        let local_var_error = ResponseContent {
591            status: local_var_status,
592            content: local_var_content,
593            entity: local_var_entity,
594        };
595        Err(Error::ResponseError(local_var_error))
596    }
597}
598
599/// Retrieve a list of group objects.
600pub async fn users_groups_list(
601    configuration: &configuration::Configuration,
602    format: Option<&str>,
603    id: Option<Vec<i32>>,
604    id__gt: Option<Vec<i32>>,
605    id__gte: Option<Vec<i32>>,
606    id__lt: Option<Vec<i32>>,
607    id__lte: Option<Vec<i32>>,
608    id__n: Option<Vec<i32>>,
609    limit: Option<i32>,
610    name: Option<Vec<String>>,
611    name__ic: Option<Vec<String>>,
612    name__ie: Option<Vec<String>>,
613    name__iew: Option<Vec<String>>,
614    name__ire: Option<Vec<String>>,
615    name__isw: Option<Vec<String>>,
616    name__n: Option<Vec<String>>,
617    name__nic: Option<Vec<String>>,
618    name__nie: Option<Vec<String>>,
619    name__niew: Option<Vec<String>>,
620    name__nire: Option<Vec<String>>,
621    name__nisw: Option<Vec<String>>,
622    name__nre: Option<Vec<String>>,
623    name__re: Option<Vec<String>>,
624    offset: Option<i32>,
625    q: Option<&str>,
626    sort: Option<&str>,
627    depth: Option<i32>,
628    exclude_m2m: Option<bool>,
629) -> Result<crate::models::PaginatedGroupList, Error<UsersGroupsListError>> {
630    let local_var_configuration = configuration;
631
632    let local_var_client = &local_var_configuration.client;
633
634    let local_var_uri_str = format!("{}/users/groups/", local_var_configuration.base_path);
635    let mut local_var_req_builder =
636        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
637
638    if let Some(ref local_var_str) = format {
639        local_var_req_builder =
640            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
641    }
642    if let Some(ref local_var_str) = id {
643        local_var_req_builder = match "multi" {
644            "multi" => local_var_req_builder.query(
645                &local_var_str
646                    .into_iter()
647                    .map(|p| ("id".to_owned(), p.to_string()))
648                    .collect::<Vec<(std::string::String, std::string::String)>>(),
649            ),
650            _ => local_var_req_builder.query(&[(
651                "id",
652                &local_var_str
653                    .into_iter()
654                    .map(|p| p.to_string())
655                    .collect::<Vec<String>>()
656                    .join(",")
657                    .to_string(),
658            )]),
659        };
660    }
661    if let Some(ref local_var_str) = id__gt {
662        local_var_req_builder = match "multi" {
663            "multi" => local_var_req_builder.query(
664                &local_var_str
665                    .into_iter()
666                    .map(|p| ("id__gt".to_owned(), p.to_string()))
667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
668            ),
669            _ => local_var_req_builder.query(&[(
670                "id__gt",
671                &local_var_str
672                    .into_iter()
673                    .map(|p| p.to_string())
674                    .collect::<Vec<String>>()
675                    .join(",")
676                    .to_string(),
677            )]),
678        };
679    }
680    if let Some(ref local_var_str) = id__gte {
681        local_var_req_builder = match "multi" {
682            "multi" => local_var_req_builder.query(
683                &local_var_str
684                    .into_iter()
685                    .map(|p| ("id__gte".to_owned(), p.to_string()))
686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
687            ),
688            _ => local_var_req_builder.query(&[(
689                "id__gte",
690                &local_var_str
691                    .into_iter()
692                    .map(|p| p.to_string())
693                    .collect::<Vec<String>>()
694                    .join(",")
695                    .to_string(),
696            )]),
697        };
698    }
699    if let Some(ref local_var_str) = id__lt {
700        local_var_req_builder = match "multi" {
701            "multi" => local_var_req_builder.query(
702                &local_var_str
703                    .into_iter()
704                    .map(|p| ("id__lt".to_owned(), p.to_string()))
705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
706            ),
707            _ => local_var_req_builder.query(&[(
708                "id__lt",
709                &local_var_str
710                    .into_iter()
711                    .map(|p| p.to_string())
712                    .collect::<Vec<String>>()
713                    .join(",")
714                    .to_string(),
715            )]),
716        };
717    }
718    if let Some(ref local_var_str) = id__lte {
719        local_var_req_builder = match "multi" {
720            "multi" => local_var_req_builder.query(
721                &local_var_str
722                    .into_iter()
723                    .map(|p| ("id__lte".to_owned(), p.to_string()))
724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
725            ),
726            _ => local_var_req_builder.query(&[(
727                "id__lte",
728                &local_var_str
729                    .into_iter()
730                    .map(|p| p.to_string())
731                    .collect::<Vec<String>>()
732                    .join(",")
733                    .to_string(),
734            )]),
735        };
736    }
737    if let Some(ref local_var_str) = id__n {
738        local_var_req_builder = match "multi" {
739            "multi" => local_var_req_builder.query(
740                &local_var_str
741                    .into_iter()
742                    .map(|p| ("id__n".to_owned(), p.to_string()))
743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
744            ),
745            _ => local_var_req_builder.query(&[(
746                "id__n",
747                &local_var_str
748                    .into_iter()
749                    .map(|p| p.to_string())
750                    .collect::<Vec<String>>()
751                    .join(",")
752                    .to_string(),
753            )]),
754        };
755    }
756    if let Some(ref local_var_str) = limit {
757        local_var_req_builder =
758            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
759    }
760    if let Some(ref local_var_str) = name {
761        local_var_req_builder = match "multi" {
762            "multi" => local_var_req_builder.query(
763                &local_var_str
764                    .into_iter()
765                    .map(|p| ("name".to_owned(), p.to_string()))
766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
767            ),
768            _ => local_var_req_builder.query(&[(
769                "name",
770                &local_var_str
771                    .into_iter()
772                    .map(|p| p.to_string())
773                    .collect::<Vec<String>>()
774                    .join(",")
775                    .to_string(),
776            )]),
777        };
778    }
779    if let Some(ref local_var_str) = name__ic {
780        local_var_req_builder = match "multi" {
781            "multi" => local_var_req_builder.query(
782                &local_var_str
783                    .into_iter()
784                    .map(|p| ("name__ic".to_owned(), p.to_string()))
785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
786            ),
787            _ => local_var_req_builder.query(&[(
788                "name__ic",
789                &local_var_str
790                    .into_iter()
791                    .map(|p| p.to_string())
792                    .collect::<Vec<String>>()
793                    .join(",")
794                    .to_string(),
795            )]),
796        };
797    }
798    if let Some(ref local_var_str) = name__ie {
799        local_var_req_builder = match "multi" {
800            "multi" => local_var_req_builder.query(
801                &local_var_str
802                    .into_iter()
803                    .map(|p| ("name__ie".to_owned(), p.to_string()))
804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
805            ),
806            _ => local_var_req_builder.query(&[(
807                "name__ie",
808                &local_var_str
809                    .into_iter()
810                    .map(|p| p.to_string())
811                    .collect::<Vec<String>>()
812                    .join(",")
813                    .to_string(),
814            )]),
815        };
816    }
817    if let Some(ref local_var_str) = name__iew {
818        local_var_req_builder = match "multi" {
819            "multi" => local_var_req_builder.query(
820                &local_var_str
821                    .into_iter()
822                    .map(|p| ("name__iew".to_owned(), p.to_string()))
823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
824            ),
825            _ => local_var_req_builder.query(&[(
826                "name__iew",
827                &local_var_str
828                    .into_iter()
829                    .map(|p| p.to_string())
830                    .collect::<Vec<String>>()
831                    .join(",")
832                    .to_string(),
833            )]),
834        };
835    }
836    if let Some(ref local_var_str) = name__ire {
837        local_var_req_builder = match "multi" {
838            "multi" => local_var_req_builder.query(
839                &local_var_str
840                    .into_iter()
841                    .map(|p| ("name__ire".to_owned(), p.to_string()))
842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
843            ),
844            _ => local_var_req_builder.query(&[(
845                "name__ire",
846                &local_var_str
847                    .into_iter()
848                    .map(|p| p.to_string())
849                    .collect::<Vec<String>>()
850                    .join(",")
851                    .to_string(),
852            )]),
853        };
854    }
855    if let Some(ref local_var_str) = name__isw {
856        local_var_req_builder = match "multi" {
857            "multi" => local_var_req_builder.query(
858                &local_var_str
859                    .into_iter()
860                    .map(|p| ("name__isw".to_owned(), p.to_string()))
861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
862            ),
863            _ => local_var_req_builder.query(&[(
864                "name__isw",
865                &local_var_str
866                    .into_iter()
867                    .map(|p| p.to_string())
868                    .collect::<Vec<String>>()
869                    .join(",")
870                    .to_string(),
871            )]),
872        };
873    }
874    if let Some(ref local_var_str) = name__n {
875        local_var_req_builder = match "multi" {
876            "multi" => local_var_req_builder.query(
877                &local_var_str
878                    .into_iter()
879                    .map(|p| ("name__n".to_owned(), p.to_string()))
880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
881            ),
882            _ => local_var_req_builder.query(&[(
883                "name__n",
884                &local_var_str
885                    .into_iter()
886                    .map(|p| p.to_string())
887                    .collect::<Vec<String>>()
888                    .join(",")
889                    .to_string(),
890            )]),
891        };
892    }
893    if let Some(ref local_var_str) = name__nic {
894        local_var_req_builder = match "multi" {
895            "multi" => local_var_req_builder.query(
896                &local_var_str
897                    .into_iter()
898                    .map(|p| ("name__nic".to_owned(), p.to_string()))
899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
900            ),
901            _ => local_var_req_builder.query(&[(
902                "name__nic",
903                &local_var_str
904                    .into_iter()
905                    .map(|p| p.to_string())
906                    .collect::<Vec<String>>()
907                    .join(",")
908                    .to_string(),
909            )]),
910        };
911    }
912    if let Some(ref local_var_str) = name__nie {
913        local_var_req_builder = match "multi" {
914            "multi" => local_var_req_builder.query(
915                &local_var_str
916                    .into_iter()
917                    .map(|p| ("name__nie".to_owned(), p.to_string()))
918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
919            ),
920            _ => local_var_req_builder.query(&[(
921                "name__nie",
922                &local_var_str
923                    .into_iter()
924                    .map(|p| p.to_string())
925                    .collect::<Vec<String>>()
926                    .join(",")
927                    .to_string(),
928            )]),
929        };
930    }
931    if let Some(ref local_var_str) = name__niew {
932        local_var_req_builder = match "multi" {
933            "multi" => local_var_req_builder.query(
934                &local_var_str
935                    .into_iter()
936                    .map(|p| ("name__niew".to_owned(), p.to_string()))
937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
938            ),
939            _ => local_var_req_builder.query(&[(
940                "name__niew",
941                &local_var_str
942                    .into_iter()
943                    .map(|p| p.to_string())
944                    .collect::<Vec<String>>()
945                    .join(",")
946                    .to_string(),
947            )]),
948        };
949    }
950    if let Some(ref local_var_str) = name__nire {
951        local_var_req_builder = match "multi" {
952            "multi" => local_var_req_builder.query(
953                &local_var_str
954                    .into_iter()
955                    .map(|p| ("name__nire".to_owned(), p.to_string()))
956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
957            ),
958            _ => local_var_req_builder.query(&[(
959                "name__nire",
960                &local_var_str
961                    .into_iter()
962                    .map(|p| p.to_string())
963                    .collect::<Vec<String>>()
964                    .join(",")
965                    .to_string(),
966            )]),
967        };
968    }
969    if let Some(ref local_var_str) = name__nisw {
970        local_var_req_builder = match "multi" {
971            "multi" => local_var_req_builder.query(
972                &local_var_str
973                    .into_iter()
974                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
976            ),
977            _ => local_var_req_builder.query(&[(
978                "name__nisw",
979                &local_var_str
980                    .into_iter()
981                    .map(|p| p.to_string())
982                    .collect::<Vec<String>>()
983                    .join(",")
984                    .to_string(),
985            )]),
986        };
987    }
988    if let Some(ref local_var_str) = name__nre {
989        local_var_req_builder = match "multi" {
990            "multi" => local_var_req_builder.query(
991                &local_var_str
992                    .into_iter()
993                    .map(|p| ("name__nre".to_owned(), p.to_string()))
994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
995            ),
996            _ => local_var_req_builder.query(&[(
997                "name__nre",
998                &local_var_str
999                    .into_iter()
1000                    .map(|p| p.to_string())
1001                    .collect::<Vec<String>>()
1002                    .join(",")
1003                    .to_string(),
1004            )]),
1005        };
1006    }
1007    if let Some(ref local_var_str) = name__re {
1008        local_var_req_builder = match "multi" {
1009            "multi" => local_var_req_builder.query(
1010                &local_var_str
1011                    .into_iter()
1012                    .map(|p| ("name__re".to_owned(), p.to_string()))
1013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1014            ),
1015            _ => local_var_req_builder.query(&[(
1016                "name__re",
1017                &local_var_str
1018                    .into_iter()
1019                    .map(|p| p.to_string())
1020                    .collect::<Vec<String>>()
1021                    .join(",")
1022                    .to_string(),
1023            )]),
1024        };
1025    }
1026    if let Some(ref local_var_str) = offset {
1027        local_var_req_builder =
1028            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1029    }
1030    if let Some(ref local_var_str) = q {
1031        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1032    }
1033    if let Some(ref local_var_str) = sort {
1034        local_var_req_builder =
1035            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
1036    }
1037    if let Some(ref local_var_str) = depth {
1038        local_var_req_builder =
1039            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1040    }
1041    if let Some(ref local_var_str) = exclude_m2m {
1042        local_var_req_builder =
1043            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1044    }
1045    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1046        local_var_req_builder =
1047            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1048    }
1049    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1050        let local_var_key = local_var_apikey.key.clone();
1051        let local_var_value = match local_var_apikey.prefix {
1052            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1053            None => local_var_key,
1054        };
1055        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1056    };
1057
1058    let local_var_req = local_var_req_builder.build()?;
1059    let local_var_resp = local_var_client.execute(local_var_req).await?;
1060
1061    let local_var_status = local_var_resp.status();
1062    let local_var_content = local_var_resp.text().await?;
1063
1064    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1065        serde_json::from_str(&local_var_content).map_err(Error::from)
1066    } else {
1067        let local_var_entity: Option<UsersGroupsListError> =
1068            serde_json::from_str(&local_var_content).ok();
1069        let local_var_error = ResponseContent {
1070            status: local_var_status,
1071            content: local_var_content,
1072            entity: local_var_entity,
1073        };
1074        Err(Error::ResponseError(local_var_error))
1075    }
1076}
1077
1078/// Partial update a group object.
1079pub async fn users_groups_partial_update(
1080    configuration: &configuration::Configuration,
1081    id: i32,
1082    format: Option<&str>,
1083    patched_group_request: Option<crate::models::PatchedGroupRequest>,
1084) -> Result<crate::models::Group, Error<UsersGroupsPartialUpdateError>> {
1085    let local_var_configuration = configuration;
1086
1087    let local_var_client = &local_var_configuration.client;
1088
1089    let local_var_uri_str = format!(
1090        "{}/users/groups/{id}/",
1091        local_var_configuration.base_path,
1092        id = id
1093    );
1094    let mut local_var_req_builder =
1095        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1096
1097    if let Some(ref local_var_str) = format {
1098        local_var_req_builder =
1099            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1100    }
1101    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1102        local_var_req_builder =
1103            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1104    }
1105    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1106        let local_var_key = local_var_apikey.key.clone();
1107        let local_var_value = match local_var_apikey.prefix {
1108            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1109            None => local_var_key,
1110        };
1111        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1112    };
1113    local_var_req_builder = local_var_req_builder.json(&patched_group_request);
1114
1115    let local_var_req = local_var_req_builder.build()?;
1116    let local_var_resp = local_var_client.execute(local_var_req).await?;
1117
1118    let local_var_status = local_var_resp.status();
1119    let local_var_content = local_var_resp.text().await?;
1120
1121    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1122        serde_json::from_str(&local_var_content).map_err(Error::from)
1123    } else {
1124        let local_var_entity: Option<UsersGroupsPartialUpdateError> =
1125            serde_json::from_str(&local_var_content).ok();
1126        let local_var_error = ResponseContent {
1127            status: local_var_status,
1128            content: local_var_content,
1129            entity: local_var_entity,
1130        };
1131        Err(Error::ResponseError(local_var_error))
1132    }
1133}
1134
1135/// Retrieve a group object.
1136pub async fn users_groups_retrieve(
1137    configuration: &configuration::Configuration,
1138    id: i32,
1139    format: Option<&str>,
1140    depth: Option<i32>,
1141    exclude_m2m: Option<bool>,
1142) -> Result<crate::models::Group, Error<UsersGroupsRetrieveError>> {
1143    let local_var_configuration = configuration;
1144
1145    let local_var_client = &local_var_configuration.client;
1146
1147    let local_var_uri_str = format!(
1148        "{}/users/groups/{id}/",
1149        local_var_configuration.base_path,
1150        id = id
1151    );
1152    let mut local_var_req_builder =
1153        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1154
1155    if let Some(ref local_var_str) = format {
1156        local_var_req_builder =
1157            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1158    }
1159    if let Some(ref local_var_str) = depth {
1160        local_var_req_builder =
1161            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1162    }
1163    if let Some(ref local_var_str) = exclude_m2m {
1164        local_var_req_builder =
1165            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1166    }
1167    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1168        local_var_req_builder =
1169            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1170    }
1171    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1172        let local_var_key = local_var_apikey.key.clone();
1173        let local_var_value = match local_var_apikey.prefix {
1174            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1175            None => local_var_key,
1176        };
1177        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1178    };
1179
1180    let local_var_req = local_var_req_builder.build()?;
1181    let local_var_resp = local_var_client.execute(local_var_req).await?;
1182
1183    let local_var_status = local_var_resp.status();
1184    let local_var_content = local_var_resp.text().await?;
1185
1186    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1187        serde_json::from_str(&local_var_content).map_err(Error::from)
1188    } else {
1189        let local_var_entity: Option<UsersGroupsRetrieveError> =
1190            serde_json::from_str(&local_var_content).ok();
1191        let local_var_error = ResponseContent {
1192            status: local_var_status,
1193            content: local_var_content,
1194            entity: local_var_entity,
1195        };
1196        Err(Error::ResponseError(local_var_error))
1197    }
1198}
1199
1200/// Update a group object.
1201pub async fn users_groups_update(
1202    configuration: &configuration::Configuration,
1203    id: i32,
1204    group_request: crate::models::GroupRequest,
1205    format: Option<&str>,
1206) -> Result<crate::models::Group, Error<UsersGroupsUpdateError>> {
1207    let local_var_configuration = configuration;
1208
1209    let local_var_client = &local_var_configuration.client;
1210
1211    let local_var_uri_str = format!(
1212        "{}/users/groups/{id}/",
1213        local_var_configuration.base_path,
1214        id = id
1215    );
1216    let mut local_var_req_builder =
1217        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1218
1219    if let Some(ref local_var_str) = format {
1220        local_var_req_builder =
1221            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1222    }
1223    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1224        local_var_req_builder =
1225            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1226    }
1227    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1228        let local_var_key = local_var_apikey.key.clone();
1229        let local_var_value = match local_var_apikey.prefix {
1230            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1231            None => local_var_key,
1232        };
1233        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1234    };
1235    local_var_req_builder = local_var_req_builder.json(&group_request);
1236
1237    let local_var_req = local_var_req_builder.build()?;
1238    let local_var_resp = local_var_client.execute(local_var_req).await?;
1239
1240    let local_var_status = local_var_resp.status();
1241    let local_var_content = local_var_resp.text().await?;
1242
1243    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1244        serde_json::from_str(&local_var_content).map_err(Error::from)
1245    } else {
1246        let local_var_entity: Option<UsersGroupsUpdateError> =
1247            serde_json::from_str(&local_var_content).ok();
1248        let local_var_error = ResponseContent {
1249            status: local_var_status,
1250            content: local_var_content,
1251            entity: local_var_entity,
1252        };
1253        Err(Error::ResponseError(local_var_error))
1254    }
1255}
1256
1257/// Destroy a list of permission objects.
1258pub async fn users_permissions_bulk_destroy(
1259    configuration: &configuration::Configuration,
1260    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
1261    format: Option<&str>,
1262) -> Result<(), Error<UsersPermissionsBulkDestroyError>> {
1263    let local_var_configuration = configuration;
1264
1265    let local_var_client = &local_var_configuration.client;
1266
1267    let local_var_uri_str = format!("{}/users/permissions/", local_var_configuration.base_path);
1268    let mut local_var_req_builder =
1269        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1270
1271    if let Some(ref local_var_str) = format {
1272        local_var_req_builder =
1273            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1274    }
1275    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1276        local_var_req_builder =
1277            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1278    }
1279    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1280        let local_var_key = local_var_apikey.key.clone();
1281        let local_var_value = match local_var_apikey.prefix {
1282            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1283            None => local_var_key,
1284        };
1285        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1286    };
1287    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
1288
1289    let local_var_req = local_var_req_builder.build()?;
1290    let local_var_resp = local_var_client.execute(local_var_req).await?;
1291
1292    let local_var_status = local_var_resp.status();
1293    let local_var_content = local_var_resp.text().await?;
1294
1295    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1296        Ok(())
1297    } else {
1298        let local_var_entity: Option<UsersPermissionsBulkDestroyError> =
1299            serde_json::from_str(&local_var_content).ok();
1300        let local_var_error = ResponseContent {
1301            status: local_var_status,
1302            content: local_var_content,
1303            entity: local_var_entity,
1304        };
1305        Err(Error::ResponseError(local_var_error))
1306    }
1307}
1308
1309/// Partial update a list of permission objects.
1310pub async fn users_permissions_bulk_partial_update(
1311    configuration: &configuration::Configuration,
1312    patched_bulk_writable_object_permission_request: Vec<
1313        crate::models::PatchedBulkWritableObjectPermissionRequest,
1314    >,
1315    format: Option<&str>,
1316) -> Result<Vec<crate::models::ObjectPermission>, Error<UsersPermissionsBulkPartialUpdateError>> {
1317    let local_var_configuration = configuration;
1318
1319    let local_var_client = &local_var_configuration.client;
1320
1321    let local_var_uri_str = format!("{}/users/permissions/", local_var_configuration.base_path);
1322    let mut local_var_req_builder =
1323        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1324
1325    if let Some(ref local_var_str) = format {
1326        local_var_req_builder =
1327            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1328    }
1329    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1330        local_var_req_builder =
1331            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1332    }
1333    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1334        let local_var_key = local_var_apikey.key.clone();
1335        let local_var_value = match local_var_apikey.prefix {
1336            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1337            None => local_var_key,
1338        };
1339        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1340    };
1341    local_var_req_builder =
1342        local_var_req_builder.json(&patched_bulk_writable_object_permission_request);
1343
1344    let local_var_req = local_var_req_builder.build()?;
1345    let local_var_resp = local_var_client.execute(local_var_req).await?;
1346
1347    let local_var_status = local_var_resp.status();
1348    let local_var_content = local_var_resp.text().await?;
1349
1350    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1351        serde_json::from_str(&local_var_content).map_err(Error::from)
1352    } else {
1353        let local_var_entity: Option<UsersPermissionsBulkPartialUpdateError> =
1354            serde_json::from_str(&local_var_content).ok();
1355        let local_var_error = ResponseContent {
1356            status: local_var_status,
1357            content: local_var_content,
1358            entity: local_var_entity,
1359        };
1360        Err(Error::ResponseError(local_var_error))
1361    }
1362}
1363
1364/// Update a list of permission objects.
1365pub async fn users_permissions_bulk_update(
1366    configuration: &configuration::Configuration,
1367    bulk_writable_object_permission_request: Vec<
1368        crate::models::BulkWritableObjectPermissionRequest,
1369    >,
1370    format: Option<&str>,
1371) -> Result<Vec<crate::models::ObjectPermission>, Error<UsersPermissionsBulkUpdateError>> {
1372    let local_var_configuration = configuration;
1373
1374    let local_var_client = &local_var_configuration.client;
1375
1376    let local_var_uri_str = format!("{}/users/permissions/", local_var_configuration.base_path);
1377    let mut local_var_req_builder =
1378        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1379
1380    if let Some(ref local_var_str) = format {
1381        local_var_req_builder =
1382            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1383    }
1384    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1385        local_var_req_builder =
1386            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1387    }
1388    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1389        let local_var_key = local_var_apikey.key.clone();
1390        let local_var_value = match local_var_apikey.prefix {
1391            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1392            None => local_var_key,
1393        };
1394        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1395    };
1396    local_var_req_builder = local_var_req_builder.json(&bulk_writable_object_permission_request);
1397
1398    let local_var_req = local_var_req_builder.build()?;
1399    let local_var_resp = local_var_client.execute(local_var_req).await?;
1400
1401    let local_var_status = local_var_resp.status();
1402    let local_var_content = local_var_resp.text().await?;
1403
1404    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1405        serde_json::from_str(&local_var_content).map_err(Error::from)
1406    } else {
1407        let local_var_entity: Option<UsersPermissionsBulkUpdateError> =
1408            serde_json::from_str(&local_var_content).ok();
1409        let local_var_error = ResponseContent {
1410            status: local_var_status,
1411            content: local_var_content,
1412            entity: local_var_entity,
1413        };
1414        Err(Error::ResponseError(local_var_error))
1415    }
1416}
1417
1418/// Create one or more permission objects.
1419pub async fn users_permissions_create(
1420    configuration: &configuration::Configuration,
1421    object_permission_request: crate::models::ObjectPermissionRequest,
1422    format: Option<&str>,
1423) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsCreateError>> {
1424    let local_var_configuration = configuration;
1425
1426    let local_var_client = &local_var_configuration.client;
1427
1428    let local_var_uri_str = format!("{}/users/permissions/", local_var_configuration.base_path);
1429    let mut local_var_req_builder =
1430        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1431
1432    if let Some(ref local_var_str) = format {
1433        local_var_req_builder =
1434            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1435    }
1436    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1437        local_var_req_builder =
1438            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1439    }
1440    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1441        let local_var_key = local_var_apikey.key.clone();
1442        let local_var_value = match local_var_apikey.prefix {
1443            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1444            None => local_var_key,
1445        };
1446        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1447    };
1448    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
1449
1450    let local_var_req = local_var_req_builder.build()?;
1451    let local_var_resp = local_var_client.execute(local_var_req).await?;
1452
1453    let local_var_status = local_var_resp.status();
1454    let local_var_content = local_var_resp.text().await?;
1455
1456    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1457        serde_json::from_str(&local_var_content).map_err(Error::from)
1458    } else {
1459        let local_var_entity: Option<UsersPermissionsCreateError> =
1460            serde_json::from_str(&local_var_content).ok();
1461        let local_var_error = ResponseContent {
1462            status: local_var_status,
1463            content: local_var_content,
1464            entity: local_var_entity,
1465        };
1466        Err(Error::ResponseError(local_var_error))
1467    }
1468}
1469
1470/// Destroy a permission object.
1471pub async fn users_permissions_destroy(
1472    configuration: &configuration::Configuration,
1473    id: &str,
1474    format: Option<&str>,
1475) -> Result<(), Error<UsersPermissionsDestroyError>> {
1476    let local_var_configuration = configuration;
1477
1478    let local_var_client = &local_var_configuration.client;
1479
1480    let local_var_uri_str = format!(
1481        "{}/users/permissions/{id}/",
1482        local_var_configuration.base_path,
1483        id = crate::apis::urlencode(id)
1484    );
1485    let mut local_var_req_builder =
1486        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1487
1488    if let Some(ref local_var_str) = format {
1489        local_var_req_builder =
1490            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1491    }
1492    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1493        local_var_req_builder =
1494            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1495    }
1496    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1497        let local_var_key = local_var_apikey.key.clone();
1498        let local_var_value = match local_var_apikey.prefix {
1499            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1500            None => local_var_key,
1501        };
1502        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1503    };
1504
1505    let local_var_req = local_var_req_builder.build()?;
1506    let local_var_resp = local_var_client.execute(local_var_req).await?;
1507
1508    let local_var_status = local_var_resp.status();
1509    let local_var_content = local_var_resp.text().await?;
1510
1511    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1512        Ok(())
1513    } else {
1514        let local_var_entity: Option<UsersPermissionsDestroyError> =
1515            serde_json::from_str(&local_var_content).ok();
1516        let local_var_error = ResponseContent {
1517            status: local_var_status,
1518            content: local_var_content,
1519            entity: local_var_entity,
1520        };
1521        Err(Error::ResponseError(local_var_error))
1522    }
1523}
1524
1525/// Retrieve a list of permission objects.
1526pub async fn users_permissions_list(
1527    configuration: &configuration::Configuration,
1528    description: Option<Vec<String>>,
1529    description__ic: Option<Vec<String>>,
1530    description__ie: Option<Vec<String>>,
1531    description__iew: Option<Vec<String>>,
1532    description__ire: Option<Vec<String>>,
1533    description__isw: Option<Vec<String>>,
1534    description__n: Option<Vec<String>>,
1535    description__nic: Option<Vec<String>>,
1536    description__nie: Option<Vec<String>>,
1537    description__niew: Option<Vec<String>>,
1538    description__nire: Option<Vec<String>>,
1539    description__nisw: Option<Vec<String>>,
1540    description__nre: Option<Vec<String>>,
1541    description__re: Option<Vec<String>>,
1542    enabled: Option<bool>,
1543    format: Option<&str>,
1544    groups: Option<Vec<String>>,
1545    groups__n: Option<Vec<String>>,
1546    groups_id: Option<Vec<i32>>,
1547    groups_id__n: Option<Vec<i32>>,
1548    id: Option<Vec<uuid::Uuid>>,
1549    id__n: Option<Vec<uuid::Uuid>>,
1550    limit: Option<i32>,
1551    name: Option<Vec<String>>,
1552    name__ic: Option<Vec<String>>,
1553    name__ie: Option<Vec<String>>,
1554    name__iew: Option<Vec<String>>,
1555    name__ire: Option<Vec<String>>,
1556    name__isw: Option<Vec<String>>,
1557    name__n: Option<Vec<String>>,
1558    name__nic: Option<Vec<String>>,
1559    name__nie: Option<Vec<String>>,
1560    name__niew: Option<Vec<String>>,
1561    name__nire: Option<Vec<String>>,
1562    name__nisw: Option<Vec<String>>,
1563    name__nre: Option<Vec<String>>,
1564    name__re: Option<Vec<String>>,
1565    object_types: Option<Vec<i32>>,
1566    object_types__n: Option<Vec<i32>>,
1567    offset: Option<i32>,
1568    q: Option<&str>,
1569    sort: Option<&str>,
1570    users: Option<Vec<String>>,
1571    users__n: Option<Vec<String>>,
1572    depth: Option<i32>,
1573    exclude_m2m: Option<bool>,
1574) -> Result<crate::models::PaginatedObjectPermissionList, Error<UsersPermissionsListError>> {
1575    let local_var_configuration = configuration;
1576
1577    let local_var_client = &local_var_configuration.client;
1578
1579    let local_var_uri_str = format!("{}/users/permissions/", local_var_configuration.base_path);
1580    let mut local_var_req_builder =
1581        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1582
1583    if let Some(ref local_var_str) = description {
1584        local_var_req_builder = match "multi" {
1585            "multi" => local_var_req_builder.query(
1586                &local_var_str
1587                    .into_iter()
1588                    .map(|p| ("description".to_owned(), p.to_string()))
1589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1590            ),
1591            _ => local_var_req_builder.query(&[(
1592                "description",
1593                &local_var_str
1594                    .into_iter()
1595                    .map(|p| p.to_string())
1596                    .collect::<Vec<String>>()
1597                    .join(",")
1598                    .to_string(),
1599            )]),
1600        };
1601    }
1602    if let Some(ref local_var_str) = description__ic {
1603        local_var_req_builder = match "multi" {
1604            "multi" => local_var_req_builder.query(
1605                &local_var_str
1606                    .into_iter()
1607                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1609            ),
1610            _ => local_var_req_builder.query(&[(
1611                "description__ic",
1612                &local_var_str
1613                    .into_iter()
1614                    .map(|p| p.to_string())
1615                    .collect::<Vec<String>>()
1616                    .join(",")
1617                    .to_string(),
1618            )]),
1619        };
1620    }
1621    if let Some(ref local_var_str) = description__ie {
1622        local_var_req_builder = match "multi" {
1623            "multi" => local_var_req_builder.query(
1624                &local_var_str
1625                    .into_iter()
1626                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1628            ),
1629            _ => local_var_req_builder.query(&[(
1630                "description__ie",
1631                &local_var_str
1632                    .into_iter()
1633                    .map(|p| p.to_string())
1634                    .collect::<Vec<String>>()
1635                    .join(",")
1636                    .to_string(),
1637            )]),
1638        };
1639    }
1640    if let Some(ref local_var_str) = description__iew {
1641        local_var_req_builder = match "multi" {
1642            "multi" => local_var_req_builder.query(
1643                &local_var_str
1644                    .into_iter()
1645                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1647            ),
1648            _ => local_var_req_builder.query(&[(
1649                "description__iew",
1650                &local_var_str
1651                    .into_iter()
1652                    .map(|p| p.to_string())
1653                    .collect::<Vec<String>>()
1654                    .join(",")
1655                    .to_string(),
1656            )]),
1657        };
1658    }
1659    if let Some(ref local_var_str) = description__ire {
1660        local_var_req_builder = match "multi" {
1661            "multi" => local_var_req_builder.query(
1662                &local_var_str
1663                    .into_iter()
1664                    .map(|p| ("description__ire".to_owned(), p.to_string()))
1665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1666            ),
1667            _ => local_var_req_builder.query(&[(
1668                "description__ire",
1669                &local_var_str
1670                    .into_iter()
1671                    .map(|p| p.to_string())
1672                    .collect::<Vec<String>>()
1673                    .join(",")
1674                    .to_string(),
1675            )]),
1676        };
1677    }
1678    if let Some(ref local_var_str) = description__isw {
1679        local_var_req_builder = match "multi" {
1680            "multi" => local_var_req_builder.query(
1681                &local_var_str
1682                    .into_iter()
1683                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1685            ),
1686            _ => local_var_req_builder.query(&[(
1687                "description__isw",
1688                &local_var_str
1689                    .into_iter()
1690                    .map(|p| p.to_string())
1691                    .collect::<Vec<String>>()
1692                    .join(",")
1693                    .to_string(),
1694            )]),
1695        };
1696    }
1697    if let Some(ref local_var_str) = description__n {
1698        local_var_req_builder = match "multi" {
1699            "multi" => local_var_req_builder.query(
1700                &local_var_str
1701                    .into_iter()
1702                    .map(|p| ("description__n".to_owned(), p.to_string()))
1703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1704            ),
1705            _ => local_var_req_builder.query(&[(
1706                "description__n",
1707                &local_var_str
1708                    .into_iter()
1709                    .map(|p| p.to_string())
1710                    .collect::<Vec<String>>()
1711                    .join(",")
1712                    .to_string(),
1713            )]),
1714        };
1715    }
1716    if let Some(ref local_var_str) = description__nic {
1717        local_var_req_builder = match "multi" {
1718            "multi" => local_var_req_builder.query(
1719                &local_var_str
1720                    .into_iter()
1721                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1723            ),
1724            _ => local_var_req_builder.query(&[(
1725                "description__nic",
1726                &local_var_str
1727                    .into_iter()
1728                    .map(|p| p.to_string())
1729                    .collect::<Vec<String>>()
1730                    .join(",")
1731                    .to_string(),
1732            )]),
1733        };
1734    }
1735    if let Some(ref local_var_str) = description__nie {
1736        local_var_req_builder = match "multi" {
1737            "multi" => local_var_req_builder.query(
1738                &local_var_str
1739                    .into_iter()
1740                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1742            ),
1743            _ => local_var_req_builder.query(&[(
1744                "description__nie",
1745                &local_var_str
1746                    .into_iter()
1747                    .map(|p| p.to_string())
1748                    .collect::<Vec<String>>()
1749                    .join(",")
1750                    .to_string(),
1751            )]),
1752        };
1753    }
1754    if let Some(ref local_var_str) = description__niew {
1755        local_var_req_builder = match "multi" {
1756            "multi" => local_var_req_builder.query(
1757                &local_var_str
1758                    .into_iter()
1759                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1761            ),
1762            _ => local_var_req_builder.query(&[(
1763                "description__niew",
1764                &local_var_str
1765                    .into_iter()
1766                    .map(|p| p.to_string())
1767                    .collect::<Vec<String>>()
1768                    .join(",")
1769                    .to_string(),
1770            )]),
1771        };
1772    }
1773    if let Some(ref local_var_str) = description__nire {
1774        local_var_req_builder = match "multi" {
1775            "multi" => local_var_req_builder.query(
1776                &local_var_str
1777                    .into_iter()
1778                    .map(|p| ("description__nire".to_owned(), p.to_string()))
1779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1780            ),
1781            _ => local_var_req_builder.query(&[(
1782                "description__nire",
1783                &local_var_str
1784                    .into_iter()
1785                    .map(|p| p.to_string())
1786                    .collect::<Vec<String>>()
1787                    .join(",")
1788                    .to_string(),
1789            )]),
1790        };
1791    }
1792    if let Some(ref local_var_str) = description__nisw {
1793        local_var_req_builder = match "multi" {
1794            "multi" => local_var_req_builder.query(
1795                &local_var_str
1796                    .into_iter()
1797                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1799            ),
1800            _ => local_var_req_builder.query(&[(
1801                "description__nisw",
1802                &local_var_str
1803                    .into_iter()
1804                    .map(|p| p.to_string())
1805                    .collect::<Vec<String>>()
1806                    .join(",")
1807                    .to_string(),
1808            )]),
1809        };
1810    }
1811    if let Some(ref local_var_str) = description__nre {
1812        local_var_req_builder = match "multi" {
1813            "multi" => local_var_req_builder.query(
1814                &local_var_str
1815                    .into_iter()
1816                    .map(|p| ("description__nre".to_owned(), p.to_string()))
1817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1818            ),
1819            _ => local_var_req_builder.query(&[(
1820                "description__nre",
1821                &local_var_str
1822                    .into_iter()
1823                    .map(|p| p.to_string())
1824                    .collect::<Vec<String>>()
1825                    .join(",")
1826                    .to_string(),
1827            )]),
1828        };
1829    }
1830    if let Some(ref local_var_str) = description__re {
1831        local_var_req_builder = match "multi" {
1832            "multi" => local_var_req_builder.query(
1833                &local_var_str
1834                    .into_iter()
1835                    .map(|p| ("description__re".to_owned(), p.to_string()))
1836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1837            ),
1838            _ => local_var_req_builder.query(&[(
1839                "description__re",
1840                &local_var_str
1841                    .into_iter()
1842                    .map(|p| p.to_string())
1843                    .collect::<Vec<String>>()
1844                    .join(",")
1845                    .to_string(),
1846            )]),
1847        };
1848    }
1849    if let Some(ref local_var_str) = enabled {
1850        local_var_req_builder =
1851            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
1852    }
1853    if let Some(ref local_var_str) = format {
1854        local_var_req_builder =
1855            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1856    }
1857    if let Some(ref local_var_str) = groups {
1858        local_var_req_builder = match "multi" {
1859            "multi" => local_var_req_builder.query(
1860                &local_var_str
1861                    .into_iter()
1862                    .map(|p| ("groups".to_owned(), p.to_string()))
1863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1864            ),
1865            _ => local_var_req_builder.query(&[(
1866                "groups",
1867                &local_var_str
1868                    .into_iter()
1869                    .map(|p| p.to_string())
1870                    .collect::<Vec<String>>()
1871                    .join(",")
1872                    .to_string(),
1873            )]),
1874        };
1875    }
1876    if let Some(ref local_var_str) = groups__n {
1877        local_var_req_builder = match "multi" {
1878            "multi" => local_var_req_builder.query(
1879                &local_var_str
1880                    .into_iter()
1881                    .map(|p| ("groups__n".to_owned(), p.to_string()))
1882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1883            ),
1884            _ => local_var_req_builder.query(&[(
1885                "groups__n",
1886                &local_var_str
1887                    .into_iter()
1888                    .map(|p| p.to_string())
1889                    .collect::<Vec<String>>()
1890                    .join(",")
1891                    .to_string(),
1892            )]),
1893        };
1894    }
1895    if let Some(ref local_var_str) = groups_id {
1896        local_var_req_builder = match "multi" {
1897            "multi" => local_var_req_builder.query(
1898                &local_var_str
1899                    .into_iter()
1900                    .map(|p| ("groups_id".to_owned(), p.to_string()))
1901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1902            ),
1903            _ => local_var_req_builder.query(&[(
1904                "groups_id",
1905                &local_var_str
1906                    .into_iter()
1907                    .map(|p| p.to_string())
1908                    .collect::<Vec<String>>()
1909                    .join(",")
1910                    .to_string(),
1911            )]),
1912        };
1913    }
1914    if let Some(ref local_var_str) = groups_id__n {
1915        local_var_req_builder = match "multi" {
1916            "multi" => local_var_req_builder.query(
1917                &local_var_str
1918                    .into_iter()
1919                    .map(|p| ("groups_id__n".to_owned(), p.to_string()))
1920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1921            ),
1922            _ => local_var_req_builder.query(&[(
1923                "groups_id__n",
1924                &local_var_str
1925                    .into_iter()
1926                    .map(|p| p.to_string())
1927                    .collect::<Vec<String>>()
1928                    .join(",")
1929                    .to_string(),
1930            )]),
1931        };
1932    }
1933    if let Some(ref local_var_str) = id {
1934        local_var_req_builder = match "multi" {
1935            "multi" => local_var_req_builder.query(
1936                &local_var_str
1937                    .into_iter()
1938                    .map(|p| ("id".to_owned(), p.to_string()))
1939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1940            ),
1941            _ => local_var_req_builder.query(&[(
1942                "id",
1943                &local_var_str
1944                    .into_iter()
1945                    .map(|p| p.to_string())
1946                    .collect::<Vec<String>>()
1947                    .join(",")
1948                    .to_string(),
1949            )]),
1950        };
1951    }
1952    if let Some(ref local_var_str) = id__n {
1953        local_var_req_builder = match "multi" {
1954            "multi" => local_var_req_builder.query(
1955                &local_var_str
1956                    .into_iter()
1957                    .map(|p| ("id__n".to_owned(), p.to_string()))
1958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1959            ),
1960            _ => local_var_req_builder.query(&[(
1961                "id__n",
1962                &local_var_str
1963                    .into_iter()
1964                    .map(|p| p.to_string())
1965                    .collect::<Vec<String>>()
1966                    .join(",")
1967                    .to_string(),
1968            )]),
1969        };
1970    }
1971    if let Some(ref local_var_str) = limit {
1972        local_var_req_builder =
1973            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1974    }
1975    if let Some(ref local_var_str) = name {
1976        local_var_req_builder = match "multi" {
1977            "multi" => local_var_req_builder.query(
1978                &local_var_str
1979                    .into_iter()
1980                    .map(|p| ("name".to_owned(), p.to_string()))
1981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1982            ),
1983            _ => local_var_req_builder.query(&[(
1984                "name",
1985                &local_var_str
1986                    .into_iter()
1987                    .map(|p| p.to_string())
1988                    .collect::<Vec<String>>()
1989                    .join(",")
1990                    .to_string(),
1991            )]),
1992        };
1993    }
1994    if let Some(ref local_var_str) = name__ic {
1995        local_var_req_builder = match "multi" {
1996            "multi" => local_var_req_builder.query(
1997                &local_var_str
1998                    .into_iter()
1999                    .map(|p| ("name__ic".to_owned(), p.to_string()))
2000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2001            ),
2002            _ => local_var_req_builder.query(&[(
2003                "name__ic",
2004                &local_var_str
2005                    .into_iter()
2006                    .map(|p| p.to_string())
2007                    .collect::<Vec<String>>()
2008                    .join(",")
2009                    .to_string(),
2010            )]),
2011        };
2012    }
2013    if let Some(ref local_var_str) = name__ie {
2014        local_var_req_builder = match "multi" {
2015            "multi" => local_var_req_builder.query(
2016                &local_var_str
2017                    .into_iter()
2018                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2020            ),
2021            _ => local_var_req_builder.query(&[(
2022                "name__ie",
2023                &local_var_str
2024                    .into_iter()
2025                    .map(|p| p.to_string())
2026                    .collect::<Vec<String>>()
2027                    .join(",")
2028                    .to_string(),
2029            )]),
2030        };
2031    }
2032    if let Some(ref local_var_str) = name__iew {
2033        local_var_req_builder = match "multi" {
2034            "multi" => local_var_req_builder.query(
2035                &local_var_str
2036                    .into_iter()
2037                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2039            ),
2040            _ => local_var_req_builder.query(&[(
2041                "name__iew",
2042                &local_var_str
2043                    .into_iter()
2044                    .map(|p| p.to_string())
2045                    .collect::<Vec<String>>()
2046                    .join(",")
2047                    .to_string(),
2048            )]),
2049        };
2050    }
2051    if let Some(ref local_var_str) = name__ire {
2052        local_var_req_builder = match "multi" {
2053            "multi" => local_var_req_builder.query(
2054                &local_var_str
2055                    .into_iter()
2056                    .map(|p| ("name__ire".to_owned(), p.to_string()))
2057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2058            ),
2059            _ => local_var_req_builder.query(&[(
2060                "name__ire",
2061                &local_var_str
2062                    .into_iter()
2063                    .map(|p| p.to_string())
2064                    .collect::<Vec<String>>()
2065                    .join(",")
2066                    .to_string(),
2067            )]),
2068        };
2069    }
2070    if let Some(ref local_var_str) = name__isw {
2071        local_var_req_builder = match "multi" {
2072            "multi" => local_var_req_builder.query(
2073                &local_var_str
2074                    .into_iter()
2075                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2077            ),
2078            _ => local_var_req_builder.query(&[(
2079                "name__isw",
2080                &local_var_str
2081                    .into_iter()
2082                    .map(|p| p.to_string())
2083                    .collect::<Vec<String>>()
2084                    .join(",")
2085                    .to_string(),
2086            )]),
2087        };
2088    }
2089    if let Some(ref local_var_str) = name__n {
2090        local_var_req_builder = match "multi" {
2091            "multi" => local_var_req_builder.query(
2092                &local_var_str
2093                    .into_iter()
2094                    .map(|p| ("name__n".to_owned(), p.to_string()))
2095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2096            ),
2097            _ => local_var_req_builder.query(&[(
2098                "name__n",
2099                &local_var_str
2100                    .into_iter()
2101                    .map(|p| p.to_string())
2102                    .collect::<Vec<String>>()
2103                    .join(",")
2104                    .to_string(),
2105            )]),
2106        };
2107    }
2108    if let Some(ref local_var_str) = name__nic {
2109        local_var_req_builder = match "multi" {
2110            "multi" => local_var_req_builder.query(
2111                &local_var_str
2112                    .into_iter()
2113                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2115            ),
2116            _ => local_var_req_builder.query(&[(
2117                "name__nic",
2118                &local_var_str
2119                    .into_iter()
2120                    .map(|p| p.to_string())
2121                    .collect::<Vec<String>>()
2122                    .join(",")
2123                    .to_string(),
2124            )]),
2125        };
2126    }
2127    if let Some(ref local_var_str) = name__nie {
2128        local_var_req_builder = match "multi" {
2129            "multi" => local_var_req_builder.query(
2130                &local_var_str
2131                    .into_iter()
2132                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2134            ),
2135            _ => local_var_req_builder.query(&[(
2136                "name__nie",
2137                &local_var_str
2138                    .into_iter()
2139                    .map(|p| p.to_string())
2140                    .collect::<Vec<String>>()
2141                    .join(",")
2142                    .to_string(),
2143            )]),
2144        };
2145    }
2146    if let Some(ref local_var_str) = name__niew {
2147        local_var_req_builder = match "multi" {
2148            "multi" => local_var_req_builder.query(
2149                &local_var_str
2150                    .into_iter()
2151                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2153            ),
2154            _ => local_var_req_builder.query(&[(
2155                "name__niew",
2156                &local_var_str
2157                    .into_iter()
2158                    .map(|p| p.to_string())
2159                    .collect::<Vec<String>>()
2160                    .join(",")
2161                    .to_string(),
2162            )]),
2163        };
2164    }
2165    if let Some(ref local_var_str) = name__nire {
2166        local_var_req_builder = match "multi" {
2167            "multi" => local_var_req_builder.query(
2168                &local_var_str
2169                    .into_iter()
2170                    .map(|p| ("name__nire".to_owned(), p.to_string()))
2171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2172            ),
2173            _ => local_var_req_builder.query(&[(
2174                "name__nire",
2175                &local_var_str
2176                    .into_iter()
2177                    .map(|p| p.to_string())
2178                    .collect::<Vec<String>>()
2179                    .join(",")
2180                    .to_string(),
2181            )]),
2182        };
2183    }
2184    if let Some(ref local_var_str) = name__nisw {
2185        local_var_req_builder = match "multi" {
2186            "multi" => local_var_req_builder.query(
2187                &local_var_str
2188                    .into_iter()
2189                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2191            ),
2192            _ => local_var_req_builder.query(&[(
2193                "name__nisw",
2194                &local_var_str
2195                    .into_iter()
2196                    .map(|p| p.to_string())
2197                    .collect::<Vec<String>>()
2198                    .join(",")
2199                    .to_string(),
2200            )]),
2201        };
2202    }
2203    if let Some(ref local_var_str) = name__nre {
2204        local_var_req_builder = match "multi" {
2205            "multi" => local_var_req_builder.query(
2206                &local_var_str
2207                    .into_iter()
2208                    .map(|p| ("name__nre".to_owned(), p.to_string()))
2209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2210            ),
2211            _ => local_var_req_builder.query(&[(
2212                "name__nre",
2213                &local_var_str
2214                    .into_iter()
2215                    .map(|p| p.to_string())
2216                    .collect::<Vec<String>>()
2217                    .join(",")
2218                    .to_string(),
2219            )]),
2220        };
2221    }
2222    if let Some(ref local_var_str) = name__re {
2223        local_var_req_builder = match "multi" {
2224            "multi" => local_var_req_builder.query(
2225                &local_var_str
2226                    .into_iter()
2227                    .map(|p| ("name__re".to_owned(), p.to_string()))
2228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2229            ),
2230            _ => local_var_req_builder.query(&[(
2231                "name__re",
2232                &local_var_str
2233                    .into_iter()
2234                    .map(|p| p.to_string())
2235                    .collect::<Vec<String>>()
2236                    .join(",")
2237                    .to_string(),
2238            )]),
2239        };
2240    }
2241    if let Some(ref local_var_str) = object_types {
2242        local_var_req_builder = match "multi" {
2243            "multi" => local_var_req_builder.query(
2244                &local_var_str
2245                    .into_iter()
2246                    .map(|p| ("object_types".to_owned(), p.to_string()))
2247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2248            ),
2249            _ => local_var_req_builder.query(&[(
2250                "object_types",
2251                &local_var_str
2252                    .into_iter()
2253                    .map(|p| p.to_string())
2254                    .collect::<Vec<String>>()
2255                    .join(",")
2256                    .to_string(),
2257            )]),
2258        };
2259    }
2260    if let Some(ref local_var_str) = object_types__n {
2261        local_var_req_builder = match "multi" {
2262            "multi" => local_var_req_builder.query(
2263                &local_var_str
2264                    .into_iter()
2265                    .map(|p| ("object_types__n".to_owned(), p.to_string()))
2266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2267            ),
2268            _ => local_var_req_builder.query(&[(
2269                "object_types__n",
2270                &local_var_str
2271                    .into_iter()
2272                    .map(|p| p.to_string())
2273                    .collect::<Vec<String>>()
2274                    .join(",")
2275                    .to_string(),
2276            )]),
2277        };
2278    }
2279    if let Some(ref local_var_str) = offset {
2280        local_var_req_builder =
2281            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2282    }
2283    if let Some(ref local_var_str) = q {
2284        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2285    }
2286    if let Some(ref local_var_str) = sort {
2287        local_var_req_builder =
2288            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
2289    }
2290    if let Some(ref local_var_str) = users {
2291        local_var_req_builder = match "multi" {
2292            "multi" => local_var_req_builder.query(
2293                &local_var_str
2294                    .into_iter()
2295                    .map(|p| ("users".to_owned(), p.to_string()))
2296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2297            ),
2298            _ => local_var_req_builder.query(&[(
2299                "users",
2300                &local_var_str
2301                    .into_iter()
2302                    .map(|p| p.to_string())
2303                    .collect::<Vec<String>>()
2304                    .join(",")
2305                    .to_string(),
2306            )]),
2307        };
2308    }
2309    if let Some(ref local_var_str) = users__n {
2310        local_var_req_builder = match "multi" {
2311            "multi" => local_var_req_builder.query(
2312                &local_var_str
2313                    .into_iter()
2314                    .map(|p| ("users__n".to_owned(), p.to_string()))
2315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2316            ),
2317            _ => local_var_req_builder.query(&[(
2318                "users__n",
2319                &local_var_str
2320                    .into_iter()
2321                    .map(|p| p.to_string())
2322                    .collect::<Vec<String>>()
2323                    .join(",")
2324                    .to_string(),
2325            )]),
2326        };
2327    }
2328    if let Some(ref local_var_str) = depth {
2329        local_var_req_builder =
2330            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2331    }
2332    if let Some(ref local_var_str) = exclude_m2m {
2333        local_var_req_builder =
2334            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2335    }
2336    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2337        local_var_req_builder =
2338            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2339    }
2340    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2341        let local_var_key = local_var_apikey.key.clone();
2342        let local_var_value = match local_var_apikey.prefix {
2343            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2344            None => local_var_key,
2345        };
2346        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2347    };
2348
2349    let local_var_req = local_var_req_builder.build()?;
2350    let local_var_resp = local_var_client.execute(local_var_req).await?;
2351
2352    let local_var_status = local_var_resp.status();
2353    let local_var_content = local_var_resp.text().await?;
2354
2355    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2356        serde_json::from_str(&local_var_content).map_err(Error::from)
2357    } else {
2358        let local_var_entity: Option<UsersPermissionsListError> =
2359            serde_json::from_str(&local_var_content).ok();
2360        let local_var_error = ResponseContent {
2361            status: local_var_status,
2362            content: local_var_content,
2363            entity: local_var_entity,
2364        };
2365        Err(Error::ResponseError(local_var_error))
2366    }
2367}
2368
2369/// Partial update a permission object.
2370pub async fn users_permissions_partial_update(
2371    configuration: &configuration::Configuration,
2372    id: &str,
2373    format: Option<&str>,
2374    patched_object_permission_request: Option<crate::models::PatchedObjectPermissionRequest>,
2375) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsPartialUpdateError>> {
2376    let local_var_configuration = configuration;
2377
2378    let local_var_client = &local_var_configuration.client;
2379
2380    let local_var_uri_str = format!(
2381        "{}/users/permissions/{id}/",
2382        local_var_configuration.base_path,
2383        id = crate::apis::urlencode(id)
2384    );
2385    let mut local_var_req_builder =
2386        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2387
2388    if let Some(ref local_var_str) = format {
2389        local_var_req_builder =
2390            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2391    }
2392    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2393        local_var_req_builder =
2394            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2395    }
2396    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2397        let local_var_key = local_var_apikey.key.clone();
2398        let local_var_value = match local_var_apikey.prefix {
2399            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2400            None => local_var_key,
2401        };
2402        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2403    };
2404    local_var_req_builder = local_var_req_builder.json(&patched_object_permission_request);
2405
2406    let local_var_req = local_var_req_builder.build()?;
2407    let local_var_resp = local_var_client.execute(local_var_req).await?;
2408
2409    let local_var_status = local_var_resp.status();
2410    let local_var_content = local_var_resp.text().await?;
2411
2412    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2413        serde_json::from_str(&local_var_content).map_err(Error::from)
2414    } else {
2415        let local_var_entity: Option<UsersPermissionsPartialUpdateError> =
2416            serde_json::from_str(&local_var_content).ok();
2417        let local_var_error = ResponseContent {
2418            status: local_var_status,
2419            content: local_var_content,
2420            entity: local_var_entity,
2421        };
2422        Err(Error::ResponseError(local_var_error))
2423    }
2424}
2425
2426/// Retrieve a permission object.
2427pub async fn users_permissions_retrieve(
2428    configuration: &configuration::Configuration,
2429    id: &str,
2430    format: Option<&str>,
2431    depth: Option<i32>,
2432    exclude_m2m: Option<bool>,
2433) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsRetrieveError>> {
2434    let local_var_configuration = configuration;
2435
2436    let local_var_client = &local_var_configuration.client;
2437
2438    let local_var_uri_str = format!(
2439        "{}/users/permissions/{id}/",
2440        local_var_configuration.base_path,
2441        id = crate::apis::urlencode(id)
2442    );
2443    let mut local_var_req_builder =
2444        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2445
2446    if let Some(ref local_var_str) = format {
2447        local_var_req_builder =
2448            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2449    }
2450    if let Some(ref local_var_str) = depth {
2451        local_var_req_builder =
2452            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2453    }
2454    if let Some(ref local_var_str) = exclude_m2m {
2455        local_var_req_builder =
2456            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2457    }
2458    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2459        local_var_req_builder =
2460            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2461    }
2462    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2463        let local_var_key = local_var_apikey.key.clone();
2464        let local_var_value = match local_var_apikey.prefix {
2465            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2466            None => local_var_key,
2467        };
2468        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2469    };
2470
2471    let local_var_req = local_var_req_builder.build()?;
2472    let local_var_resp = local_var_client.execute(local_var_req).await?;
2473
2474    let local_var_status = local_var_resp.status();
2475    let local_var_content = local_var_resp.text().await?;
2476
2477    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2478        serde_json::from_str(&local_var_content).map_err(Error::from)
2479    } else {
2480        let local_var_entity: Option<UsersPermissionsRetrieveError> =
2481            serde_json::from_str(&local_var_content).ok();
2482        let local_var_error = ResponseContent {
2483            status: local_var_status,
2484            content: local_var_content,
2485            entity: local_var_entity,
2486        };
2487        Err(Error::ResponseError(local_var_error))
2488    }
2489}
2490
2491/// Update a permission object.
2492pub async fn users_permissions_update(
2493    configuration: &configuration::Configuration,
2494    id: &str,
2495    object_permission_request: crate::models::ObjectPermissionRequest,
2496    format: Option<&str>,
2497) -> Result<crate::models::ObjectPermission, Error<UsersPermissionsUpdateError>> {
2498    let local_var_configuration = configuration;
2499
2500    let local_var_client = &local_var_configuration.client;
2501
2502    let local_var_uri_str = format!(
2503        "{}/users/permissions/{id}/",
2504        local_var_configuration.base_path,
2505        id = crate::apis::urlencode(id)
2506    );
2507    let mut local_var_req_builder =
2508        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2509
2510    if let Some(ref local_var_str) = format {
2511        local_var_req_builder =
2512            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2513    }
2514    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2515        local_var_req_builder =
2516            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2517    }
2518    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2519        let local_var_key = local_var_apikey.key.clone();
2520        let local_var_value = match local_var_apikey.prefix {
2521            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2522            None => local_var_key,
2523        };
2524        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2525    };
2526    local_var_req_builder = local_var_req_builder.json(&object_permission_request);
2527
2528    let local_var_req = local_var_req_builder.build()?;
2529    let local_var_resp = local_var_client.execute(local_var_req).await?;
2530
2531    let local_var_status = local_var_resp.status();
2532    let local_var_content = local_var_resp.text().await?;
2533
2534    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2535        serde_json::from_str(&local_var_content).map_err(Error::from)
2536    } else {
2537        let local_var_entity: Option<UsersPermissionsUpdateError> =
2538            serde_json::from_str(&local_var_content).ok();
2539        let local_var_error = ResponseContent {
2540            status: local_var_status,
2541            content: local_var_content,
2542            entity: local_var_entity,
2543        };
2544        Err(Error::ResponseError(local_var_error))
2545    }
2546}
2547
2548/// Destroy a list of token objects.
2549pub async fn users_tokens_bulk_destroy(
2550    configuration: &configuration::Configuration,
2551    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
2552    format: Option<&str>,
2553) -> Result<(), Error<UsersTokensBulkDestroyError>> {
2554    let local_var_configuration = configuration;
2555
2556    let local_var_client = &local_var_configuration.client;
2557
2558    let local_var_uri_str = format!("{}/users/tokens/", local_var_configuration.base_path);
2559    let mut local_var_req_builder =
2560        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2561
2562    if let Some(ref local_var_str) = format {
2563        local_var_req_builder =
2564            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2565    }
2566    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2567        local_var_req_builder =
2568            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2569    }
2570    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2571        local_var_req_builder = local_var_req_builder.basic_auth(
2572            local_var_auth_conf.0.to_owned(),
2573            local_var_auth_conf.1.to_owned(),
2574        );
2575    };
2576    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2577        let local_var_key = local_var_apikey.key.clone();
2578        let local_var_value = match local_var_apikey.prefix {
2579            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2580            None => local_var_key,
2581        };
2582        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2583    };
2584    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
2585
2586    let local_var_req = local_var_req_builder.build()?;
2587    let local_var_resp = local_var_client.execute(local_var_req).await?;
2588
2589    let local_var_status = local_var_resp.status();
2590    let local_var_content = local_var_resp.text().await?;
2591
2592    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2593        Ok(())
2594    } else {
2595        let local_var_entity: Option<UsersTokensBulkDestroyError> =
2596            serde_json::from_str(&local_var_content).ok();
2597        let local_var_error = ResponseContent {
2598            status: local_var_status,
2599            content: local_var_content,
2600            entity: local_var_entity,
2601        };
2602        Err(Error::ResponseError(local_var_error))
2603    }
2604}
2605
2606/// Partial update a list of token objects.
2607pub async fn users_tokens_bulk_partial_update(
2608    configuration: &configuration::Configuration,
2609    patched_bulk_writable_token_request: Vec<crate::models::PatchedBulkWritableTokenRequest>,
2610    format: Option<&str>,
2611) -> Result<Vec<crate::models::Token>, Error<UsersTokensBulkPartialUpdateError>> {
2612    let local_var_configuration = configuration;
2613
2614    let local_var_client = &local_var_configuration.client;
2615
2616    let local_var_uri_str = format!("{}/users/tokens/", local_var_configuration.base_path);
2617    let mut local_var_req_builder =
2618        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2619
2620    if let Some(ref local_var_str) = format {
2621        local_var_req_builder =
2622            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2623    }
2624    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2625        local_var_req_builder =
2626            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2627    }
2628    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2629        local_var_req_builder = local_var_req_builder.basic_auth(
2630            local_var_auth_conf.0.to_owned(),
2631            local_var_auth_conf.1.to_owned(),
2632        );
2633    };
2634    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2635        let local_var_key = local_var_apikey.key.clone();
2636        let local_var_value = match local_var_apikey.prefix {
2637            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2638            None => local_var_key,
2639        };
2640        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2641    };
2642    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_token_request);
2643
2644    let local_var_req = local_var_req_builder.build()?;
2645    let local_var_resp = local_var_client.execute(local_var_req).await?;
2646
2647    let local_var_status = local_var_resp.status();
2648    let local_var_content = local_var_resp.text().await?;
2649
2650    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2651        serde_json::from_str(&local_var_content).map_err(Error::from)
2652    } else {
2653        let local_var_entity: Option<UsersTokensBulkPartialUpdateError> =
2654            serde_json::from_str(&local_var_content).ok();
2655        let local_var_error = ResponseContent {
2656            status: local_var_status,
2657            content: local_var_content,
2658            entity: local_var_entity,
2659        };
2660        Err(Error::ResponseError(local_var_error))
2661    }
2662}
2663
2664/// Update a list of token objects.
2665pub async fn users_tokens_bulk_update(
2666    configuration: &configuration::Configuration,
2667    bulk_writable_token_request: Vec<crate::models::BulkWritableTokenRequest>,
2668    format: Option<&str>,
2669) -> Result<Vec<crate::models::Token>, Error<UsersTokensBulkUpdateError>> {
2670    let local_var_configuration = configuration;
2671
2672    let local_var_client = &local_var_configuration.client;
2673
2674    let local_var_uri_str = format!("{}/users/tokens/", local_var_configuration.base_path);
2675    let mut local_var_req_builder =
2676        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2677
2678    if let Some(ref local_var_str) = format {
2679        local_var_req_builder =
2680            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2681    }
2682    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2683        local_var_req_builder =
2684            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2685    }
2686    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2687        local_var_req_builder = local_var_req_builder.basic_auth(
2688            local_var_auth_conf.0.to_owned(),
2689            local_var_auth_conf.1.to_owned(),
2690        );
2691    };
2692    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2693        let local_var_key = local_var_apikey.key.clone();
2694        let local_var_value = match local_var_apikey.prefix {
2695            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2696            None => local_var_key,
2697        };
2698        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2699    };
2700    local_var_req_builder = local_var_req_builder.json(&bulk_writable_token_request);
2701
2702    let local_var_req = local_var_req_builder.build()?;
2703    let local_var_resp = local_var_client.execute(local_var_req).await?;
2704
2705    let local_var_status = local_var_resp.status();
2706    let local_var_content = local_var_resp.text().await?;
2707
2708    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2709        serde_json::from_str(&local_var_content).map_err(Error::from)
2710    } else {
2711        let local_var_entity: Option<UsersTokensBulkUpdateError> =
2712            serde_json::from_str(&local_var_content).ok();
2713        let local_var_error = ResponseContent {
2714            status: local_var_status,
2715            content: local_var_content,
2716            entity: local_var_entity,
2717        };
2718        Err(Error::ResponseError(local_var_error))
2719    }
2720}
2721
2722/// Create one or more token objects.
2723pub async fn users_tokens_create(
2724    configuration: &configuration::Configuration,
2725    format: Option<&str>,
2726    token_request: Option<crate::models::TokenRequest>,
2727) -> Result<crate::models::Token, Error<UsersTokensCreateError>> {
2728    let local_var_configuration = configuration;
2729
2730    let local_var_client = &local_var_configuration.client;
2731
2732    let local_var_uri_str = format!("{}/users/tokens/", local_var_configuration.base_path);
2733    let mut local_var_req_builder =
2734        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2735
2736    if let Some(ref local_var_str) = format {
2737        local_var_req_builder =
2738            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2739    }
2740    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2741        local_var_req_builder =
2742            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2743    }
2744    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2745        local_var_req_builder = local_var_req_builder.basic_auth(
2746            local_var_auth_conf.0.to_owned(),
2747            local_var_auth_conf.1.to_owned(),
2748        );
2749    };
2750    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2751        let local_var_key = local_var_apikey.key.clone();
2752        let local_var_value = match local_var_apikey.prefix {
2753            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2754            None => local_var_key,
2755        };
2756        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2757    };
2758    local_var_req_builder = local_var_req_builder.json(&token_request);
2759
2760    let local_var_req = local_var_req_builder.build()?;
2761    let local_var_resp = local_var_client.execute(local_var_req).await?;
2762
2763    let local_var_status = local_var_resp.status();
2764    let local_var_content = local_var_resp.text().await?;
2765
2766    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2767        serde_json::from_str(&local_var_content).map_err(Error::from)
2768    } else {
2769        let local_var_entity: Option<UsersTokensCreateError> =
2770            serde_json::from_str(&local_var_content).ok();
2771        let local_var_error = ResponseContent {
2772            status: local_var_status,
2773            content: local_var_content,
2774            entity: local_var_entity,
2775        };
2776        Err(Error::ResponseError(local_var_error))
2777    }
2778}
2779
2780/// Destroy a token object.
2781pub async fn users_tokens_destroy(
2782    configuration: &configuration::Configuration,
2783    id: &str,
2784    format: Option<&str>,
2785) -> Result<(), Error<UsersTokensDestroyError>> {
2786    let local_var_configuration = configuration;
2787
2788    let local_var_client = &local_var_configuration.client;
2789
2790    let local_var_uri_str = format!(
2791        "{}/users/tokens/{id}/",
2792        local_var_configuration.base_path,
2793        id = crate::apis::urlencode(id)
2794    );
2795    let mut local_var_req_builder =
2796        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2797
2798    if let Some(ref local_var_str) = format {
2799        local_var_req_builder =
2800            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2801    }
2802    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2803        local_var_req_builder =
2804            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2805    }
2806    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2807        local_var_req_builder = local_var_req_builder.basic_auth(
2808            local_var_auth_conf.0.to_owned(),
2809            local_var_auth_conf.1.to_owned(),
2810        );
2811    };
2812    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2813        let local_var_key = local_var_apikey.key.clone();
2814        let local_var_value = match local_var_apikey.prefix {
2815            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2816            None => local_var_key,
2817        };
2818        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2819    };
2820
2821    let local_var_req = local_var_req_builder.build()?;
2822    let local_var_resp = local_var_client.execute(local_var_req).await?;
2823
2824    let local_var_status = local_var_resp.status();
2825    let local_var_content = local_var_resp.text().await?;
2826
2827    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2828        Ok(())
2829    } else {
2830        let local_var_entity: Option<UsersTokensDestroyError> =
2831            serde_json::from_str(&local_var_content).ok();
2832        let local_var_error = ResponseContent {
2833            status: local_var_status,
2834            content: local_var_content,
2835            entity: local_var_entity,
2836        };
2837        Err(Error::ResponseError(local_var_error))
2838    }
2839}
2840
2841/// Retrieve a list of token objects.
2842pub async fn users_tokens_list(
2843    configuration: &configuration::Configuration,
2844    created: Option<Vec<String>>,
2845    created__gt: Option<Vec<String>>,
2846    created__gte: Option<Vec<String>>,
2847    created__lt: Option<Vec<String>>,
2848    created__lte: Option<Vec<String>>,
2849    created__n: Option<Vec<String>>,
2850    description: Option<Vec<String>>,
2851    description__ic: Option<Vec<String>>,
2852    description__ie: Option<Vec<String>>,
2853    description__iew: Option<Vec<String>>,
2854    description__ire: Option<Vec<String>>,
2855    description__isw: Option<Vec<String>>,
2856    description__n: Option<Vec<String>>,
2857    description__nic: Option<Vec<String>>,
2858    description__nie: Option<Vec<String>>,
2859    description__niew: Option<Vec<String>>,
2860    description__nire: Option<Vec<String>>,
2861    description__nisw: Option<Vec<String>>,
2862    description__nre: Option<Vec<String>>,
2863    description__re: Option<Vec<String>>,
2864    expires: Option<Vec<String>>,
2865    expires__gt: Option<Vec<String>>,
2866    expires__gte: Option<Vec<String>>,
2867    expires__isnull: Option<bool>,
2868    expires__lt: Option<Vec<String>>,
2869    expires__lte: Option<Vec<String>>,
2870    expires__n: Option<Vec<String>>,
2871    format: Option<&str>,
2872    id: Option<Vec<uuid::Uuid>>,
2873    id__n: Option<Vec<uuid::Uuid>>,
2874    key: Option<Vec<String>>,
2875    key__ic: Option<Vec<String>>,
2876    key__ie: Option<Vec<String>>,
2877    key__iew: Option<Vec<String>>,
2878    key__ire: Option<Vec<String>>,
2879    key__isw: Option<Vec<String>>,
2880    key__n: Option<Vec<String>>,
2881    key__nic: Option<Vec<String>>,
2882    key__nie: Option<Vec<String>>,
2883    key__niew: Option<Vec<String>>,
2884    key__nire: Option<Vec<String>>,
2885    key__nisw: Option<Vec<String>>,
2886    key__nre: Option<Vec<String>>,
2887    key__re: Option<Vec<String>>,
2888    limit: Option<i32>,
2889    offset: Option<i32>,
2890    q: Option<&str>,
2891    sort: Option<&str>,
2892    write_enabled: Option<bool>,
2893    depth: Option<i32>,
2894    exclude_m2m: Option<bool>,
2895) -> Result<crate::models::PaginatedTokenList, Error<UsersTokensListError>> {
2896    let local_var_configuration = configuration;
2897
2898    let local_var_client = &local_var_configuration.client;
2899
2900    let local_var_uri_str = format!("{}/users/tokens/", local_var_configuration.base_path);
2901    let mut local_var_req_builder =
2902        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2903
2904    if let Some(ref local_var_str) = created {
2905        local_var_req_builder = match "multi" {
2906            "multi" => local_var_req_builder.query(
2907                &local_var_str
2908                    .into_iter()
2909                    .map(|p| ("created".to_owned(), p.to_string()))
2910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2911            ),
2912            _ => local_var_req_builder.query(&[(
2913                "created",
2914                &local_var_str
2915                    .into_iter()
2916                    .map(|p| p.to_string())
2917                    .collect::<Vec<String>>()
2918                    .join(",")
2919                    .to_string(),
2920            )]),
2921        };
2922    }
2923    if let Some(ref local_var_str) = created__gt {
2924        local_var_req_builder = match "multi" {
2925            "multi" => local_var_req_builder.query(
2926                &local_var_str
2927                    .into_iter()
2928                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2930            ),
2931            _ => local_var_req_builder.query(&[(
2932                "created__gt",
2933                &local_var_str
2934                    .into_iter()
2935                    .map(|p| p.to_string())
2936                    .collect::<Vec<String>>()
2937                    .join(",")
2938                    .to_string(),
2939            )]),
2940        };
2941    }
2942    if let Some(ref local_var_str) = created__gte {
2943        local_var_req_builder = match "multi" {
2944            "multi" => local_var_req_builder.query(
2945                &local_var_str
2946                    .into_iter()
2947                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2949            ),
2950            _ => local_var_req_builder.query(&[(
2951                "created__gte",
2952                &local_var_str
2953                    .into_iter()
2954                    .map(|p| p.to_string())
2955                    .collect::<Vec<String>>()
2956                    .join(",")
2957                    .to_string(),
2958            )]),
2959        };
2960    }
2961    if let Some(ref local_var_str) = created__lt {
2962        local_var_req_builder = match "multi" {
2963            "multi" => local_var_req_builder.query(
2964                &local_var_str
2965                    .into_iter()
2966                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2968            ),
2969            _ => local_var_req_builder.query(&[(
2970                "created__lt",
2971                &local_var_str
2972                    .into_iter()
2973                    .map(|p| p.to_string())
2974                    .collect::<Vec<String>>()
2975                    .join(",")
2976                    .to_string(),
2977            )]),
2978        };
2979    }
2980    if let Some(ref local_var_str) = created__lte {
2981        local_var_req_builder = match "multi" {
2982            "multi" => local_var_req_builder.query(
2983                &local_var_str
2984                    .into_iter()
2985                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2987            ),
2988            _ => local_var_req_builder.query(&[(
2989                "created__lte",
2990                &local_var_str
2991                    .into_iter()
2992                    .map(|p| p.to_string())
2993                    .collect::<Vec<String>>()
2994                    .join(",")
2995                    .to_string(),
2996            )]),
2997        };
2998    }
2999    if let Some(ref local_var_str) = created__n {
3000        local_var_req_builder = match "multi" {
3001            "multi" => local_var_req_builder.query(
3002                &local_var_str
3003                    .into_iter()
3004                    .map(|p| ("created__n".to_owned(), p.to_string()))
3005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3006            ),
3007            _ => local_var_req_builder.query(&[(
3008                "created__n",
3009                &local_var_str
3010                    .into_iter()
3011                    .map(|p| p.to_string())
3012                    .collect::<Vec<String>>()
3013                    .join(",")
3014                    .to_string(),
3015            )]),
3016        };
3017    }
3018    if let Some(ref local_var_str) = description {
3019        local_var_req_builder = match "multi" {
3020            "multi" => local_var_req_builder.query(
3021                &local_var_str
3022                    .into_iter()
3023                    .map(|p| ("description".to_owned(), p.to_string()))
3024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3025            ),
3026            _ => local_var_req_builder.query(&[(
3027                "description",
3028                &local_var_str
3029                    .into_iter()
3030                    .map(|p| p.to_string())
3031                    .collect::<Vec<String>>()
3032                    .join(",")
3033                    .to_string(),
3034            )]),
3035        };
3036    }
3037    if let Some(ref local_var_str) = description__ic {
3038        local_var_req_builder = match "multi" {
3039            "multi" => local_var_req_builder.query(
3040                &local_var_str
3041                    .into_iter()
3042                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3044            ),
3045            _ => local_var_req_builder.query(&[(
3046                "description__ic",
3047                &local_var_str
3048                    .into_iter()
3049                    .map(|p| p.to_string())
3050                    .collect::<Vec<String>>()
3051                    .join(",")
3052                    .to_string(),
3053            )]),
3054        };
3055    }
3056    if let Some(ref local_var_str) = description__ie {
3057        local_var_req_builder = match "multi" {
3058            "multi" => local_var_req_builder.query(
3059                &local_var_str
3060                    .into_iter()
3061                    .map(|p| ("description__ie".to_owned(), p.to_string()))
3062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3063            ),
3064            _ => local_var_req_builder.query(&[(
3065                "description__ie",
3066                &local_var_str
3067                    .into_iter()
3068                    .map(|p| p.to_string())
3069                    .collect::<Vec<String>>()
3070                    .join(",")
3071                    .to_string(),
3072            )]),
3073        };
3074    }
3075    if let Some(ref local_var_str) = description__iew {
3076        local_var_req_builder = match "multi" {
3077            "multi" => local_var_req_builder.query(
3078                &local_var_str
3079                    .into_iter()
3080                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3082            ),
3083            _ => local_var_req_builder.query(&[(
3084                "description__iew",
3085                &local_var_str
3086                    .into_iter()
3087                    .map(|p| p.to_string())
3088                    .collect::<Vec<String>>()
3089                    .join(",")
3090                    .to_string(),
3091            )]),
3092        };
3093    }
3094    if let Some(ref local_var_str) = description__ire {
3095        local_var_req_builder = match "multi" {
3096            "multi" => local_var_req_builder.query(
3097                &local_var_str
3098                    .into_iter()
3099                    .map(|p| ("description__ire".to_owned(), p.to_string()))
3100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3101            ),
3102            _ => local_var_req_builder.query(&[(
3103                "description__ire",
3104                &local_var_str
3105                    .into_iter()
3106                    .map(|p| p.to_string())
3107                    .collect::<Vec<String>>()
3108                    .join(",")
3109                    .to_string(),
3110            )]),
3111        };
3112    }
3113    if let Some(ref local_var_str) = description__isw {
3114        local_var_req_builder = match "multi" {
3115            "multi" => local_var_req_builder.query(
3116                &local_var_str
3117                    .into_iter()
3118                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3120            ),
3121            _ => local_var_req_builder.query(&[(
3122                "description__isw",
3123                &local_var_str
3124                    .into_iter()
3125                    .map(|p| p.to_string())
3126                    .collect::<Vec<String>>()
3127                    .join(",")
3128                    .to_string(),
3129            )]),
3130        };
3131    }
3132    if let Some(ref local_var_str) = description__n {
3133        local_var_req_builder = match "multi" {
3134            "multi" => local_var_req_builder.query(
3135                &local_var_str
3136                    .into_iter()
3137                    .map(|p| ("description__n".to_owned(), p.to_string()))
3138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3139            ),
3140            _ => local_var_req_builder.query(&[(
3141                "description__n",
3142                &local_var_str
3143                    .into_iter()
3144                    .map(|p| p.to_string())
3145                    .collect::<Vec<String>>()
3146                    .join(",")
3147                    .to_string(),
3148            )]),
3149        };
3150    }
3151    if let Some(ref local_var_str) = description__nic {
3152        local_var_req_builder = match "multi" {
3153            "multi" => local_var_req_builder.query(
3154                &local_var_str
3155                    .into_iter()
3156                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3158            ),
3159            _ => local_var_req_builder.query(&[(
3160                "description__nic",
3161                &local_var_str
3162                    .into_iter()
3163                    .map(|p| p.to_string())
3164                    .collect::<Vec<String>>()
3165                    .join(",")
3166                    .to_string(),
3167            )]),
3168        };
3169    }
3170    if let Some(ref local_var_str) = description__nie {
3171        local_var_req_builder = match "multi" {
3172            "multi" => local_var_req_builder.query(
3173                &local_var_str
3174                    .into_iter()
3175                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3177            ),
3178            _ => local_var_req_builder.query(&[(
3179                "description__nie",
3180                &local_var_str
3181                    .into_iter()
3182                    .map(|p| p.to_string())
3183                    .collect::<Vec<String>>()
3184                    .join(",")
3185                    .to_string(),
3186            )]),
3187        };
3188    }
3189    if let Some(ref local_var_str) = description__niew {
3190        local_var_req_builder = match "multi" {
3191            "multi" => local_var_req_builder.query(
3192                &local_var_str
3193                    .into_iter()
3194                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3196            ),
3197            _ => local_var_req_builder.query(&[(
3198                "description__niew",
3199                &local_var_str
3200                    .into_iter()
3201                    .map(|p| p.to_string())
3202                    .collect::<Vec<String>>()
3203                    .join(",")
3204                    .to_string(),
3205            )]),
3206        };
3207    }
3208    if let Some(ref local_var_str) = description__nire {
3209        local_var_req_builder = match "multi" {
3210            "multi" => local_var_req_builder.query(
3211                &local_var_str
3212                    .into_iter()
3213                    .map(|p| ("description__nire".to_owned(), p.to_string()))
3214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3215            ),
3216            _ => local_var_req_builder.query(&[(
3217                "description__nire",
3218                &local_var_str
3219                    .into_iter()
3220                    .map(|p| p.to_string())
3221                    .collect::<Vec<String>>()
3222                    .join(",")
3223                    .to_string(),
3224            )]),
3225        };
3226    }
3227    if let Some(ref local_var_str) = description__nisw {
3228        local_var_req_builder = match "multi" {
3229            "multi" => local_var_req_builder.query(
3230                &local_var_str
3231                    .into_iter()
3232                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3234            ),
3235            _ => local_var_req_builder.query(&[(
3236                "description__nisw",
3237                &local_var_str
3238                    .into_iter()
3239                    .map(|p| p.to_string())
3240                    .collect::<Vec<String>>()
3241                    .join(",")
3242                    .to_string(),
3243            )]),
3244        };
3245    }
3246    if let Some(ref local_var_str) = description__nre {
3247        local_var_req_builder = match "multi" {
3248            "multi" => local_var_req_builder.query(
3249                &local_var_str
3250                    .into_iter()
3251                    .map(|p| ("description__nre".to_owned(), p.to_string()))
3252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3253            ),
3254            _ => local_var_req_builder.query(&[(
3255                "description__nre",
3256                &local_var_str
3257                    .into_iter()
3258                    .map(|p| p.to_string())
3259                    .collect::<Vec<String>>()
3260                    .join(",")
3261                    .to_string(),
3262            )]),
3263        };
3264    }
3265    if let Some(ref local_var_str) = description__re {
3266        local_var_req_builder = match "multi" {
3267            "multi" => local_var_req_builder.query(
3268                &local_var_str
3269                    .into_iter()
3270                    .map(|p| ("description__re".to_owned(), p.to_string()))
3271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3272            ),
3273            _ => local_var_req_builder.query(&[(
3274                "description__re",
3275                &local_var_str
3276                    .into_iter()
3277                    .map(|p| p.to_string())
3278                    .collect::<Vec<String>>()
3279                    .join(",")
3280                    .to_string(),
3281            )]),
3282        };
3283    }
3284    if let Some(ref local_var_str) = expires {
3285        local_var_req_builder = match "multi" {
3286            "multi" => local_var_req_builder.query(
3287                &local_var_str
3288                    .into_iter()
3289                    .map(|p| ("expires".to_owned(), p.to_string()))
3290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3291            ),
3292            _ => local_var_req_builder.query(&[(
3293                "expires",
3294                &local_var_str
3295                    .into_iter()
3296                    .map(|p| p.to_string())
3297                    .collect::<Vec<String>>()
3298                    .join(",")
3299                    .to_string(),
3300            )]),
3301        };
3302    }
3303    if let Some(ref local_var_str) = expires__gt {
3304        local_var_req_builder = match "multi" {
3305            "multi" => local_var_req_builder.query(
3306                &local_var_str
3307                    .into_iter()
3308                    .map(|p| ("expires__gt".to_owned(), p.to_string()))
3309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3310            ),
3311            _ => local_var_req_builder.query(&[(
3312                "expires__gt",
3313                &local_var_str
3314                    .into_iter()
3315                    .map(|p| p.to_string())
3316                    .collect::<Vec<String>>()
3317                    .join(",")
3318                    .to_string(),
3319            )]),
3320        };
3321    }
3322    if let Some(ref local_var_str) = expires__gte {
3323        local_var_req_builder = match "multi" {
3324            "multi" => local_var_req_builder.query(
3325                &local_var_str
3326                    .into_iter()
3327                    .map(|p| ("expires__gte".to_owned(), p.to_string()))
3328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3329            ),
3330            _ => local_var_req_builder.query(&[(
3331                "expires__gte",
3332                &local_var_str
3333                    .into_iter()
3334                    .map(|p| p.to_string())
3335                    .collect::<Vec<String>>()
3336                    .join(",")
3337                    .to_string(),
3338            )]),
3339        };
3340    }
3341    if let Some(ref local_var_str) = expires__isnull {
3342        local_var_req_builder =
3343            local_var_req_builder.query(&[("expires__isnull", &local_var_str.to_string())]);
3344    }
3345    if let Some(ref local_var_str) = expires__lt {
3346        local_var_req_builder = match "multi" {
3347            "multi" => local_var_req_builder.query(
3348                &local_var_str
3349                    .into_iter()
3350                    .map(|p| ("expires__lt".to_owned(), p.to_string()))
3351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3352            ),
3353            _ => local_var_req_builder.query(&[(
3354                "expires__lt",
3355                &local_var_str
3356                    .into_iter()
3357                    .map(|p| p.to_string())
3358                    .collect::<Vec<String>>()
3359                    .join(",")
3360                    .to_string(),
3361            )]),
3362        };
3363    }
3364    if let Some(ref local_var_str) = expires__lte {
3365        local_var_req_builder = match "multi" {
3366            "multi" => local_var_req_builder.query(
3367                &local_var_str
3368                    .into_iter()
3369                    .map(|p| ("expires__lte".to_owned(), p.to_string()))
3370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3371            ),
3372            _ => local_var_req_builder.query(&[(
3373                "expires__lte",
3374                &local_var_str
3375                    .into_iter()
3376                    .map(|p| p.to_string())
3377                    .collect::<Vec<String>>()
3378                    .join(",")
3379                    .to_string(),
3380            )]),
3381        };
3382    }
3383    if let Some(ref local_var_str) = expires__n {
3384        local_var_req_builder = match "multi" {
3385            "multi" => local_var_req_builder.query(
3386                &local_var_str
3387                    .into_iter()
3388                    .map(|p| ("expires__n".to_owned(), p.to_string()))
3389                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3390            ),
3391            _ => local_var_req_builder.query(&[(
3392                "expires__n",
3393                &local_var_str
3394                    .into_iter()
3395                    .map(|p| p.to_string())
3396                    .collect::<Vec<String>>()
3397                    .join(",")
3398                    .to_string(),
3399            )]),
3400        };
3401    }
3402    if let Some(ref local_var_str) = format {
3403        local_var_req_builder =
3404            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3405    }
3406    if let Some(ref local_var_str) = id {
3407        local_var_req_builder = match "multi" {
3408            "multi" => local_var_req_builder.query(
3409                &local_var_str
3410                    .into_iter()
3411                    .map(|p| ("id".to_owned(), p.to_string()))
3412                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3413            ),
3414            _ => local_var_req_builder.query(&[(
3415                "id",
3416                &local_var_str
3417                    .into_iter()
3418                    .map(|p| p.to_string())
3419                    .collect::<Vec<String>>()
3420                    .join(",")
3421                    .to_string(),
3422            )]),
3423        };
3424    }
3425    if let Some(ref local_var_str) = id__n {
3426        local_var_req_builder = match "multi" {
3427            "multi" => local_var_req_builder.query(
3428                &local_var_str
3429                    .into_iter()
3430                    .map(|p| ("id__n".to_owned(), p.to_string()))
3431                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3432            ),
3433            _ => local_var_req_builder.query(&[(
3434                "id__n",
3435                &local_var_str
3436                    .into_iter()
3437                    .map(|p| p.to_string())
3438                    .collect::<Vec<String>>()
3439                    .join(",")
3440                    .to_string(),
3441            )]),
3442        };
3443    }
3444    if let Some(ref local_var_str) = key {
3445        local_var_req_builder = match "multi" {
3446            "multi" => local_var_req_builder.query(
3447                &local_var_str
3448                    .into_iter()
3449                    .map(|p| ("key".to_owned(), p.to_string()))
3450                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3451            ),
3452            _ => local_var_req_builder.query(&[(
3453                "key",
3454                &local_var_str
3455                    .into_iter()
3456                    .map(|p| p.to_string())
3457                    .collect::<Vec<String>>()
3458                    .join(",")
3459                    .to_string(),
3460            )]),
3461        };
3462    }
3463    if let Some(ref local_var_str) = key__ic {
3464        local_var_req_builder = match "multi" {
3465            "multi" => local_var_req_builder.query(
3466                &local_var_str
3467                    .into_iter()
3468                    .map(|p| ("key__ic".to_owned(), p.to_string()))
3469                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3470            ),
3471            _ => local_var_req_builder.query(&[(
3472                "key__ic",
3473                &local_var_str
3474                    .into_iter()
3475                    .map(|p| p.to_string())
3476                    .collect::<Vec<String>>()
3477                    .join(",")
3478                    .to_string(),
3479            )]),
3480        };
3481    }
3482    if let Some(ref local_var_str) = key__ie {
3483        local_var_req_builder = match "multi" {
3484            "multi" => local_var_req_builder.query(
3485                &local_var_str
3486                    .into_iter()
3487                    .map(|p| ("key__ie".to_owned(), p.to_string()))
3488                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3489            ),
3490            _ => local_var_req_builder.query(&[(
3491                "key__ie",
3492                &local_var_str
3493                    .into_iter()
3494                    .map(|p| p.to_string())
3495                    .collect::<Vec<String>>()
3496                    .join(",")
3497                    .to_string(),
3498            )]),
3499        };
3500    }
3501    if let Some(ref local_var_str) = key__iew {
3502        local_var_req_builder = match "multi" {
3503            "multi" => local_var_req_builder.query(
3504                &local_var_str
3505                    .into_iter()
3506                    .map(|p| ("key__iew".to_owned(), p.to_string()))
3507                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3508            ),
3509            _ => local_var_req_builder.query(&[(
3510                "key__iew",
3511                &local_var_str
3512                    .into_iter()
3513                    .map(|p| p.to_string())
3514                    .collect::<Vec<String>>()
3515                    .join(",")
3516                    .to_string(),
3517            )]),
3518        };
3519    }
3520    if let Some(ref local_var_str) = key__ire {
3521        local_var_req_builder = match "multi" {
3522            "multi" => local_var_req_builder.query(
3523                &local_var_str
3524                    .into_iter()
3525                    .map(|p| ("key__ire".to_owned(), p.to_string()))
3526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3527            ),
3528            _ => local_var_req_builder.query(&[(
3529                "key__ire",
3530                &local_var_str
3531                    .into_iter()
3532                    .map(|p| p.to_string())
3533                    .collect::<Vec<String>>()
3534                    .join(",")
3535                    .to_string(),
3536            )]),
3537        };
3538    }
3539    if let Some(ref local_var_str) = key__isw {
3540        local_var_req_builder = match "multi" {
3541            "multi" => local_var_req_builder.query(
3542                &local_var_str
3543                    .into_iter()
3544                    .map(|p| ("key__isw".to_owned(), p.to_string()))
3545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3546            ),
3547            _ => local_var_req_builder.query(&[(
3548                "key__isw",
3549                &local_var_str
3550                    .into_iter()
3551                    .map(|p| p.to_string())
3552                    .collect::<Vec<String>>()
3553                    .join(",")
3554                    .to_string(),
3555            )]),
3556        };
3557    }
3558    if let Some(ref local_var_str) = key__n {
3559        local_var_req_builder = match "multi" {
3560            "multi" => local_var_req_builder.query(
3561                &local_var_str
3562                    .into_iter()
3563                    .map(|p| ("key__n".to_owned(), p.to_string()))
3564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3565            ),
3566            _ => local_var_req_builder.query(&[(
3567                "key__n",
3568                &local_var_str
3569                    .into_iter()
3570                    .map(|p| p.to_string())
3571                    .collect::<Vec<String>>()
3572                    .join(",")
3573                    .to_string(),
3574            )]),
3575        };
3576    }
3577    if let Some(ref local_var_str) = key__nic {
3578        local_var_req_builder = match "multi" {
3579            "multi" => local_var_req_builder.query(
3580                &local_var_str
3581                    .into_iter()
3582                    .map(|p| ("key__nic".to_owned(), p.to_string()))
3583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3584            ),
3585            _ => local_var_req_builder.query(&[(
3586                "key__nic",
3587                &local_var_str
3588                    .into_iter()
3589                    .map(|p| p.to_string())
3590                    .collect::<Vec<String>>()
3591                    .join(",")
3592                    .to_string(),
3593            )]),
3594        };
3595    }
3596    if let Some(ref local_var_str) = key__nie {
3597        local_var_req_builder = match "multi" {
3598            "multi" => local_var_req_builder.query(
3599                &local_var_str
3600                    .into_iter()
3601                    .map(|p| ("key__nie".to_owned(), p.to_string()))
3602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3603            ),
3604            _ => local_var_req_builder.query(&[(
3605                "key__nie",
3606                &local_var_str
3607                    .into_iter()
3608                    .map(|p| p.to_string())
3609                    .collect::<Vec<String>>()
3610                    .join(",")
3611                    .to_string(),
3612            )]),
3613        };
3614    }
3615    if let Some(ref local_var_str) = key__niew {
3616        local_var_req_builder = match "multi" {
3617            "multi" => local_var_req_builder.query(
3618                &local_var_str
3619                    .into_iter()
3620                    .map(|p| ("key__niew".to_owned(), p.to_string()))
3621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3622            ),
3623            _ => local_var_req_builder.query(&[(
3624                "key__niew",
3625                &local_var_str
3626                    .into_iter()
3627                    .map(|p| p.to_string())
3628                    .collect::<Vec<String>>()
3629                    .join(",")
3630                    .to_string(),
3631            )]),
3632        };
3633    }
3634    if let Some(ref local_var_str) = key__nire {
3635        local_var_req_builder = match "multi" {
3636            "multi" => local_var_req_builder.query(
3637                &local_var_str
3638                    .into_iter()
3639                    .map(|p| ("key__nire".to_owned(), p.to_string()))
3640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3641            ),
3642            _ => local_var_req_builder.query(&[(
3643                "key__nire",
3644                &local_var_str
3645                    .into_iter()
3646                    .map(|p| p.to_string())
3647                    .collect::<Vec<String>>()
3648                    .join(",")
3649                    .to_string(),
3650            )]),
3651        };
3652    }
3653    if let Some(ref local_var_str) = key__nisw {
3654        local_var_req_builder = match "multi" {
3655            "multi" => local_var_req_builder.query(
3656                &local_var_str
3657                    .into_iter()
3658                    .map(|p| ("key__nisw".to_owned(), p.to_string()))
3659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3660            ),
3661            _ => local_var_req_builder.query(&[(
3662                "key__nisw",
3663                &local_var_str
3664                    .into_iter()
3665                    .map(|p| p.to_string())
3666                    .collect::<Vec<String>>()
3667                    .join(",")
3668                    .to_string(),
3669            )]),
3670        };
3671    }
3672    if let Some(ref local_var_str) = key__nre {
3673        local_var_req_builder = match "multi" {
3674            "multi" => local_var_req_builder.query(
3675                &local_var_str
3676                    .into_iter()
3677                    .map(|p| ("key__nre".to_owned(), p.to_string()))
3678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3679            ),
3680            _ => local_var_req_builder.query(&[(
3681                "key__nre",
3682                &local_var_str
3683                    .into_iter()
3684                    .map(|p| p.to_string())
3685                    .collect::<Vec<String>>()
3686                    .join(",")
3687                    .to_string(),
3688            )]),
3689        };
3690    }
3691    if let Some(ref local_var_str) = key__re {
3692        local_var_req_builder = match "multi" {
3693            "multi" => local_var_req_builder.query(
3694                &local_var_str
3695                    .into_iter()
3696                    .map(|p| ("key__re".to_owned(), p.to_string()))
3697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3698            ),
3699            _ => local_var_req_builder.query(&[(
3700                "key__re",
3701                &local_var_str
3702                    .into_iter()
3703                    .map(|p| p.to_string())
3704                    .collect::<Vec<String>>()
3705                    .join(",")
3706                    .to_string(),
3707            )]),
3708        };
3709    }
3710    if let Some(ref local_var_str) = limit {
3711        local_var_req_builder =
3712            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3713    }
3714    if let Some(ref local_var_str) = offset {
3715        local_var_req_builder =
3716            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3717    }
3718    if let Some(ref local_var_str) = q {
3719        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3720    }
3721    if let Some(ref local_var_str) = sort {
3722        local_var_req_builder =
3723            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
3724    }
3725    if let Some(ref local_var_str) = write_enabled {
3726        local_var_req_builder =
3727            local_var_req_builder.query(&[("write_enabled", &local_var_str.to_string())]);
3728    }
3729    if let Some(ref local_var_str) = depth {
3730        local_var_req_builder =
3731            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3732    }
3733    if let Some(ref local_var_str) = exclude_m2m {
3734        local_var_req_builder =
3735            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3736    }
3737    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3738        local_var_req_builder =
3739            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3740    }
3741    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3742        local_var_req_builder = local_var_req_builder.basic_auth(
3743            local_var_auth_conf.0.to_owned(),
3744            local_var_auth_conf.1.to_owned(),
3745        );
3746    };
3747    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3748        let local_var_key = local_var_apikey.key.clone();
3749        let local_var_value = match local_var_apikey.prefix {
3750            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3751            None => local_var_key,
3752        };
3753        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3754    };
3755
3756    let local_var_req = local_var_req_builder.build()?;
3757    let local_var_resp = local_var_client.execute(local_var_req).await?;
3758
3759    let local_var_status = local_var_resp.status();
3760    let local_var_content = local_var_resp.text().await?;
3761
3762    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3763        serde_json::from_str(&local_var_content).map_err(Error::from)
3764    } else {
3765        let local_var_entity: Option<UsersTokensListError> =
3766            serde_json::from_str(&local_var_content).ok();
3767        let local_var_error = ResponseContent {
3768            status: local_var_status,
3769            content: local_var_content,
3770            entity: local_var_entity,
3771        };
3772        Err(Error::ResponseError(local_var_error))
3773    }
3774}
3775
3776/// Partial update a token object.
3777pub async fn users_tokens_partial_update(
3778    configuration: &configuration::Configuration,
3779    id: &str,
3780    format: Option<&str>,
3781    patched_token_request: Option<crate::models::PatchedTokenRequest>,
3782) -> Result<crate::models::Token, Error<UsersTokensPartialUpdateError>> {
3783    let local_var_configuration = configuration;
3784
3785    let local_var_client = &local_var_configuration.client;
3786
3787    let local_var_uri_str = format!(
3788        "{}/users/tokens/{id}/",
3789        local_var_configuration.base_path,
3790        id = crate::apis::urlencode(id)
3791    );
3792    let mut local_var_req_builder =
3793        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3794
3795    if let Some(ref local_var_str) = format {
3796        local_var_req_builder =
3797            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3798    }
3799    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3800        local_var_req_builder =
3801            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3802    }
3803    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3804        local_var_req_builder = local_var_req_builder.basic_auth(
3805            local_var_auth_conf.0.to_owned(),
3806            local_var_auth_conf.1.to_owned(),
3807        );
3808    };
3809    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3810        let local_var_key = local_var_apikey.key.clone();
3811        let local_var_value = match local_var_apikey.prefix {
3812            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3813            None => local_var_key,
3814        };
3815        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3816    };
3817    local_var_req_builder = local_var_req_builder.json(&patched_token_request);
3818
3819    let local_var_req = local_var_req_builder.build()?;
3820    let local_var_resp = local_var_client.execute(local_var_req).await?;
3821
3822    let local_var_status = local_var_resp.status();
3823    let local_var_content = local_var_resp.text().await?;
3824
3825    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3826        serde_json::from_str(&local_var_content).map_err(Error::from)
3827    } else {
3828        let local_var_entity: Option<UsersTokensPartialUpdateError> =
3829            serde_json::from_str(&local_var_content).ok();
3830        let local_var_error = ResponseContent {
3831            status: local_var_status,
3832            content: local_var_content,
3833            entity: local_var_entity,
3834        };
3835        Err(Error::ResponseError(local_var_error))
3836    }
3837}
3838
3839/// Retrieve a token object.
3840pub async fn users_tokens_retrieve(
3841    configuration: &configuration::Configuration,
3842    id: &str,
3843    format: Option<&str>,
3844    depth: Option<i32>,
3845    exclude_m2m: Option<bool>,
3846) -> Result<crate::models::Token, Error<UsersTokensRetrieveError>> {
3847    let local_var_configuration = configuration;
3848
3849    let local_var_client = &local_var_configuration.client;
3850
3851    let local_var_uri_str = format!(
3852        "{}/users/tokens/{id}/",
3853        local_var_configuration.base_path,
3854        id = crate::apis::urlencode(id)
3855    );
3856    let mut local_var_req_builder =
3857        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3858
3859    if let Some(ref local_var_str) = format {
3860        local_var_req_builder =
3861            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3862    }
3863    if let Some(ref local_var_str) = depth {
3864        local_var_req_builder =
3865            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3866    }
3867    if let Some(ref local_var_str) = exclude_m2m {
3868        local_var_req_builder =
3869            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3870    }
3871    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3872        local_var_req_builder =
3873            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3874    }
3875    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3876        local_var_req_builder = local_var_req_builder.basic_auth(
3877            local_var_auth_conf.0.to_owned(),
3878            local_var_auth_conf.1.to_owned(),
3879        );
3880    };
3881    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3882        let local_var_key = local_var_apikey.key.clone();
3883        let local_var_value = match local_var_apikey.prefix {
3884            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3885            None => local_var_key,
3886        };
3887        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3888    };
3889
3890    let local_var_req = local_var_req_builder.build()?;
3891    let local_var_resp = local_var_client.execute(local_var_req).await?;
3892
3893    let local_var_status = local_var_resp.status();
3894    let local_var_content = local_var_resp.text().await?;
3895
3896    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3897        serde_json::from_str(&local_var_content).map_err(Error::from)
3898    } else {
3899        let local_var_entity: Option<UsersTokensRetrieveError> =
3900            serde_json::from_str(&local_var_content).ok();
3901        let local_var_error = ResponseContent {
3902            status: local_var_status,
3903            content: local_var_content,
3904            entity: local_var_entity,
3905        };
3906        Err(Error::ResponseError(local_var_error))
3907    }
3908}
3909
3910/// Update a token object.
3911pub async fn users_tokens_update(
3912    configuration: &configuration::Configuration,
3913    id: &str,
3914    format: Option<&str>,
3915    token_request: Option<crate::models::TokenRequest>,
3916) -> Result<crate::models::Token, Error<UsersTokensUpdateError>> {
3917    let local_var_configuration = configuration;
3918
3919    let local_var_client = &local_var_configuration.client;
3920
3921    let local_var_uri_str = format!(
3922        "{}/users/tokens/{id}/",
3923        local_var_configuration.base_path,
3924        id = crate::apis::urlencode(id)
3925    );
3926    let mut local_var_req_builder =
3927        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3928
3929    if let Some(ref local_var_str) = format {
3930        local_var_req_builder =
3931            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3932    }
3933    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3934        local_var_req_builder =
3935            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3936    }
3937    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3938        local_var_req_builder = local_var_req_builder.basic_auth(
3939            local_var_auth_conf.0.to_owned(),
3940            local_var_auth_conf.1.to_owned(),
3941        );
3942    };
3943    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3944        let local_var_key = local_var_apikey.key.clone();
3945        let local_var_value = match local_var_apikey.prefix {
3946            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3947            None => local_var_key,
3948        };
3949        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3950    };
3951    local_var_req_builder = local_var_req_builder.json(&token_request);
3952
3953    let local_var_req = local_var_req_builder.build()?;
3954    let local_var_resp = local_var_client.execute(local_var_req).await?;
3955
3956    let local_var_status = local_var_resp.status();
3957    let local_var_content = local_var_resp.text().await?;
3958
3959    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3960        serde_json::from_str(&local_var_content).map_err(Error::from)
3961    } else {
3962        let local_var_entity: Option<UsersTokensUpdateError> =
3963            serde_json::from_str(&local_var_content).ok();
3964        let local_var_error = ResponseContent {
3965            status: local_var_status,
3966            content: local_var_content,
3967            entity: local_var_entity,
3968        };
3969        Err(Error::ResponseError(local_var_error))
3970    }
3971}
3972
3973/// Destroy a list of user objects.
3974pub async fn users_users_bulk_destroy(
3975    configuration: &configuration::Configuration,
3976    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
3977    format: Option<&str>,
3978) -> Result<(), Error<UsersUsersBulkDestroyError>> {
3979    let local_var_configuration = configuration;
3980
3981    let local_var_client = &local_var_configuration.client;
3982
3983    let local_var_uri_str = format!("{}/users/users/", local_var_configuration.base_path);
3984    let mut local_var_req_builder =
3985        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3986
3987    if let Some(ref local_var_str) = format {
3988        local_var_req_builder =
3989            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3990    }
3991    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3992        local_var_req_builder =
3993            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3994    }
3995    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3996        let local_var_key = local_var_apikey.key.clone();
3997        let local_var_value = match local_var_apikey.prefix {
3998            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3999            None => local_var_key,
4000        };
4001        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4002    };
4003    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
4004
4005    let local_var_req = local_var_req_builder.build()?;
4006    let local_var_resp = local_var_client.execute(local_var_req).await?;
4007
4008    let local_var_status = local_var_resp.status();
4009    let local_var_content = local_var_resp.text().await?;
4010
4011    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4012        Ok(())
4013    } else {
4014        let local_var_entity: Option<UsersUsersBulkDestroyError> =
4015            serde_json::from_str(&local_var_content).ok();
4016        let local_var_error = ResponseContent {
4017            status: local_var_status,
4018            content: local_var_content,
4019            entity: local_var_entity,
4020        };
4021        Err(Error::ResponseError(local_var_error))
4022    }
4023}
4024
4025/// Partial update a list of user objects.
4026pub async fn users_users_bulk_partial_update(
4027    configuration: &configuration::Configuration,
4028    patched_bulk_writable_user_request: Vec<crate::models::PatchedBulkWritableUserRequest>,
4029    format: Option<&str>,
4030) -> Result<Vec<crate::models::User>, Error<UsersUsersBulkPartialUpdateError>> {
4031    let local_var_configuration = configuration;
4032
4033    let local_var_client = &local_var_configuration.client;
4034
4035    let local_var_uri_str = format!("{}/users/users/", local_var_configuration.base_path);
4036    let mut local_var_req_builder =
4037        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4038
4039    if let Some(ref local_var_str) = format {
4040        local_var_req_builder =
4041            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4042    }
4043    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4044        local_var_req_builder =
4045            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4046    }
4047    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4048        let local_var_key = local_var_apikey.key.clone();
4049        let local_var_value = match local_var_apikey.prefix {
4050            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4051            None => local_var_key,
4052        };
4053        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4054    };
4055    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_user_request);
4056
4057    let local_var_req = local_var_req_builder.build()?;
4058    let local_var_resp = local_var_client.execute(local_var_req).await?;
4059
4060    let local_var_status = local_var_resp.status();
4061    let local_var_content = local_var_resp.text().await?;
4062
4063    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4064        serde_json::from_str(&local_var_content).map_err(Error::from)
4065    } else {
4066        let local_var_entity: Option<UsersUsersBulkPartialUpdateError> =
4067            serde_json::from_str(&local_var_content).ok();
4068        let local_var_error = ResponseContent {
4069            status: local_var_status,
4070            content: local_var_content,
4071            entity: local_var_entity,
4072        };
4073        Err(Error::ResponseError(local_var_error))
4074    }
4075}
4076
4077/// Update a list of user objects.
4078pub async fn users_users_bulk_update(
4079    configuration: &configuration::Configuration,
4080    bulk_writable_user_request: Vec<crate::models::BulkWritableUserRequest>,
4081    format: Option<&str>,
4082) -> Result<Vec<crate::models::User>, Error<UsersUsersBulkUpdateError>> {
4083    let local_var_configuration = configuration;
4084
4085    let local_var_client = &local_var_configuration.client;
4086
4087    let local_var_uri_str = format!("{}/users/users/", local_var_configuration.base_path);
4088    let mut local_var_req_builder =
4089        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4090
4091    if let Some(ref local_var_str) = format {
4092        local_var_req_builder =
4093            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4094    }
4095    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4096        local_var_req_builder =
4097            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4098    }
4099    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4100        let local_var_key = local_var_apikey.key.clone();
4101        let local_var_value = match local_var_apikey.prefix {
4102            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4103            None => local_var_key,
4104        };
4105        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4106    };
4107    local_var_req_builder = local_var_req_builder.json(&bulk_writable_user_request);
4108
4109    let local_var_req = local_var_req_builder.build()?;
4110    let local_var_resp = local_var_client.execute(local_var_req).await?;
4111
4112    let local_var_status = local_var_resp.status();
4113    let local_var_content = local_var_resp.text().await?;
4114
4115    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4116        serde_json::from_str(&local_var_content).map_err(Error::from)
4117    } else {
4118        let local_var_entity: Option<UsersUsersBulkUpdateError> =
4119            serde_json::from_str(&local_var_content).ok();
4120        let local_var_error = ResponseContent {
4121            status: local_var_status,
4122            content: local_var_content,
4123            entity: local_var_entity,
4124        };
4125        Err(Error::ResponseError(local_var_error))
4126    }
4127}
4128
4129/// Create one or more user objects.
4130pub async fn users_users_create(
4131    configuration: &configuration::Configuration,
4132    user_request: crate::models::UserRequest,
4133    format: Option<&str>,
4134) -> Result<crate::models::User, Error<UsersUsersCreateError>> {
4135    let local_var_configuration = configuration;
4136
4137    let local_var_client = &local_var_configuration.client;
4138
4139    let local_var_uri_str = format!("{}/users/users/", local_var_configuration.base_path);
4140    let mut local_var_req_builder =
4141        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4142
4143    if let Some(ref local_var_str) = format {
4144        local_var_req_builder =
4145            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4146    }
4147    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4148        local_var_req_builder =
4149            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4150    }
4151    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4152        let local_var_key = local_var_apikey.key.clone();
4153        let local_var_value = match local_var_apikey.prefix {
4154            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4155            None => local_var_key,
4156        };
4157        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4158    };
4159    local_var_req_builder = local_var_req_builder.json(&user_request);
4160
4161    let local_var_req = local_var_req_builder.build()?;
4162    let local_var_resp = local_var_client.execute(local_var_req).await?;
4163
4164    let local_var_status = local_var_resp.status();
4165    let local_var_content = local_var_resp.text().await?;
4166
4167    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4168        serde_json::from_str(&local_var_content).map_err(Error::from)
4169    } else {
4170        let local_var_entity: Option<UsersUsersCreateError> =
4171            serde_json::from_str(&local_var_content).ok();
4172        let local_var_error = ResponseContent {
4173            status: local_var_status,
4174            content: local_var_content,
4175            entity: local_var_entity,
4176        };
4177        Err(Error::ResponseError(local_var_error))
4178    }
4179}
4180
4181/// Destroy a user object.
4182pub async fn users_users_destroy(
4183    configuration: &configuration::Configuration,
4184    id: &str,
4185    format: Option<&str>,
4186) -> Result<(), Error<UsersUsersDestroyError>> {
4187    let local_var_configuration = configuration;
4188
4189    let local_var_client = &local_var_configuration.client;
4190
4191    let local_var_uri_str = format!(
4192        "{}/users/users/{id}/",
4193        local_var_configuration.base_path,
4194        id = crate::apis::urlencode(id)
4195    );
4196    let mut local_var_req_builder =
4197        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4198
4199    if let Some(ref local_var_str) = format {
4200        local_var_req_builder =
4201            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4202    }
4203    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4204        local_var_req_builder =
4205            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4206    }
4207    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4208        let local_var_key = local_var_apikey.key.clone();
4209        let local_var_value = match local_var_apikey.prefix {
4210            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4211            None => local_var_key,
4212        };
4213        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4214    };
4215
4216    let local_var_req = local_var_req_builder.build()?;
4217    let local_var_resp = local_var_client.execute(local_var_req).await?;
4218
4219    let local_var_status = local_var_resp.status();
4220    let local_var_content = local_var_resp.text().await?;
4221
4222    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4223        Ok(())
4224    } else {
4225        let local_var_entity: Option<UsersUsersDestroyError> =
4226            serde_json::from_str(&local_var_content).ok();
4227        let local_var_error = ResponseContent {
4228            status: local_var_status,
4229            content: local_var_content,
4230            entity: local_var_entity,
4231        };
4232        Err(Error::ResponseError(local_var_error))
4233    }
4234}
4235
4236/// Retrieve a list of user objects.
4237pub async fn users_users_list(
4238    configuration: &configuration::Configuration,
4239    email: Option<Vec<String>>,
4240    email__ic: Option<Vec<String>>,
4241    email__ie: Option<Vec<String>>,
4242    email__iew: Option<Vec<String>>,
4243    email__ire: Option<Vec<String>>,
4244    email__isw: Option<Vec<String>>,
4245    email__n: Option<Vec<String>>,
4246    email__nic: Option<Vec<String>>,
4247    email__nie: Option<Vec<String>>,
4248    email__niew: Option<Vec<String>>,
4249    email__nire: Option<Vec<String>>,
4250    email__nisw: Option<Vec<String>>,
4251    email__nre: Option<Vec<String>>,
4252    email__re: Option<Vec<String>>,
4253    first_name: Option<Vec<String>>,
4254    first_name__ic: Option<Vec<String>>,
4255    first_name__ie: Option<Vec<String>>,
4256    first_name__iew: Option<Vec<String>>,
4257    first_name__ire: Option<Vec<String>>,
4258    first_name__isw: Option<Vec<String>>,
4259    first_name__n: Option<Vec<String>>,
4260    first_name__nic: Option<Vec<String>>,
4261    first_name__nie: Option<Vec<String>>,
4262    first_name__niew: Option<Vec<String>>,
4263    first_name__nire: Option<Vec<String>>,
4264    first_name__nisw: Option<Vec<String>>,
4265    first_name__nre: Option<Vec<String>>,
4266    first_name__re: Option<Vec<String>>,
4267    format: Option<&str>,
4268    groups: Option<Vec<String>>,
4269    groups__n: Option<Vec<String>>,
4270    groups_id: Option<Vec<i32>>,
4271    groups_id__n: Option<Vec<i32>>,
4272    has_object_changes: Option<bool>,
4273    has_object_permissions: Option<bool>,
4274    has_rack_reservations: Option<bool>,
4275    id: Option<Vec<uuid::Uuid>>,
4276    id__n: Option<Vec<uuid::Uuid>>,
4277    is_active: Option<bool>,
4278    is_staff: Option<bool>,
4279    last_name: Option<Vec<String>>,
4280    last_name__ic: Option<Vec<String>>,
4281    last_name__ie: Option<Vec<String>>,
4282    last_name__iew: Option<Vec<String>>,
4283    last_name__ire: Option<Vec<String>>,
4284    last_name__isw: Option<Vec<String>>,
4285    last_name__n: Option<Vec<String>>,
4286    last_name__nic: Option<Vec<String>>,
4287    last_name__nie: Option<Vec<String>>,
4288    last_name__niew: Option<Vec<String>>,
4289    last_name__nire: Option<Vec<String>>,
4290    last_name__nisw: Option<Vec<String>>,
4291    last_name__nre: Option<Vec<String>>,
4292    last_name__re: Option<Vec<String>>,
4293    limit: Option<i32>,
4294    object_changes: Option<Vec<uuid::Uuid>>,
4295    object_changes__isnull: Option<bool>,
4296    object_changes__n: Option<Vec<uuid::Uuid>>,
4297    object_permissions: Option<Vec<String>>,
4298    object_permissions__isnull: Option<bool>,
4299    object_permissions__n: Option<Vec<String>>,
4300    offset: Option<i32>,
4301    q: Option<&str>,
4302    rack_reservations_id: Option<Vec<uuid::Uuid>>,
4303    rack_reservations_id__isnull: Option<bool>,
4304    rack_reservations_id__n: Option<Vec<uuid::Uuid>>,
4305    sort: Option<&str>,
4306    username: Option<Vec<String>>,
4307    username__ic: Option<Vec<String>>,
4308    username__ie: Option<Vec<String>>,
4309    username__iew: Option<Vec<String>>,
4310    username__ire: Option<Vec<String>>,
4311    username__isw: Option<Vec<String>>,
4312    username__n: Option<Vec<String>>,
4313    username__nic: Option<Vec<String>>,
4314    username__nie: Option<Vec<String>>,
4315    username__niew: Option<Vec<String>>,
4316    username__nire: Option<Vec<String>>,
4317    username__nisw: Option<Vec<String>>,
4318    username__nre: Option<Vec<String>>,
4319    username__re: Option<Vec<String>>,
4320    depth: Option<i32>,
4321    exclude_m2m: Option<bool>,
4322) -> Result<crate::models::PaginatedUserList, Error<UsersUsersListError>> {
4323    let local_var_configuration = configuration;
4324
4325    let local_var_client = &local_var_configuration.client;
4326
4327    let local_var_uri_str = format!("{}/users/users/", local_var_configuration.base_path);
4328    let mut local_var_req_builder =
4329        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4330
4331    if let Some(ref local_var_str) = email {
4332        local_var_req_builder = match "multi" {
4333            "multi" => local_var_req_builder.query(
4334                &local_var_str
4335                    .into_iter()
4336                    .map(|p| ("email".to_owned(), p.to_string()))
4337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4338            ),
4339            _ => local_var_req_builder.query(&[(
4340                "email",
4341                &local_var_str
4342                    .into_iter()
4343                    .map(|p| p.to_string())
4344                    .collect::<Vec<String>>()
4345                    .join(",")
4346                    .to_string(),
4347            )]),
4348        };
4349    }
4350    if let Some(ref local_var_str) = email__ic {
4351        local_var_req_builder = match "multi" {
4352            "multi" => local_var_req_builder.query(
4353                &local_var_str
4354                    .into_iter()
4355                    .map(|p| ("email__ic".to_owned(), p.to_string()))
4356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4357            ),
4358            _ => local_var_req_builder.query(&[(
4359                "email__ic",
4360                &local_var_str
4361                    .into_iter()
4362                    .map(|p| p.to_string())
4363                    .collect::<Vec<String>>()
4364                    .join(",")
4365                    .to_string(),
4366            )]),
4367        };
4368    }
4369    if let Some(ref local_var_str) = email__ie {
4370        local_var_req_builder = match "multi" {
4371            "multi" => local_var_req_builder.query(
4372                &local_var_str
4373                    .into_iter()
4374                    .map(|p| ("email__ie".to_owned(), p.to_string()))
4375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4376            ),
4377            _ => local_var_req_builder.query(&[(
4378                "email__ie",
4379                &local_var_str
4380                    .into_iter()
4381                    .map(|p| p.to_string())
4382                    .collect::<Vec<String>>()
4383                    .join(",")
4384                    .to_string(),
4385            )]),
4386        };
4387    }
4388    if let Some(ref local_var_str) = email__iew {
4389        local_var_req_builder = match "multi" {
4390            "multi" => local_var_req_builder.query(
4391                &local_var_str
4392                    .into_iter()
4393                    .map(|p| ("email__iew".to_owned(), p.to_string()))
4394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4395            ),
4396            _ => local_var_req_builder.query(&[(
4397                "email__iew",
4398                &local_var_str
4399                    .into_iter()
4400                    .map(|p| p.to_string())
4401                    .collect::<Vec<String>>()
4402                    .join(",")
4403                    .to_string(),
4404            )]),
4405        };
4406    }
4407    if let Some(ref local_var_str) = email__ire {
4408        local_var_req_builder = match "multi" {
4409            "multi" => local_var_req_builder.query(
4410                &local_var_str
4411                    .into_iter()
4412                    .map(|p| ("email__ire".to_owned(), p.to_string()))
4413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4414            ),
4415            _ => local_var_req_builder.query(&[(
4416                "email__ire",
4417                &local_var_str
4418                    .into_iter()
4419                    .map(|p| p.to_string())
4420                    .collect::<Vec<String>>()
4421                    .join(",")
4422                    .to_string(),
4423            )]),
4424        };
4425    }
4426    if let Some(ref local_var_str) = email__isw {
4427        local_var_req_builder = match "multi" {
4428            "multi" => local_var_req_builder.query(
4429                &local_var_str
4430                    .into_iter()
4431                    .map(|p| ("email__isw".to_owned(), p.to_string()))
4432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4433            ),
4434            _ => local_var_req_builder.query(&[(
4435                "email__isw",
4436                &local_var_str
4437                    .into_iter()
4438                    .map(|p| p.to_string())
4439                    .collect::<Vec<String>>()
4440                    .join(",")
4441                    .to_string(),
4442            )]),
4443        };
4444    }
4445    if let Some(ref local_var_str) = email__n {
4446        local_var_req_builder = match "multi" {
4447            "multi" => local_var_req_builder.query(
4448                &local_var_str
4449                    .into_iter()
4450                    .map(|p| ("email__n".to_owned(), p.to_string()))
4451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4452            ),
4453            _ => local_var_req_builder.query(&[(
4454                "email__n",
4455                &local_var_str
4456                    .into_iter()
4457                    .map(|p| p.to_string())
4458                    .collect::<Vec<String>>()
4459                    .join(",")
4460                    .to_string(),
4461            )]),
4462        };
4463    }
4464    if let Some(ref local_var_str) = email__nic {
4465        local_var_req_builder = match "multi" {
4466            "multi" => local_var_req_builder.query(
4467                &local_var_str
4468                    .into_iter()
4469                    .map(|p| ("email__nic".to_owned(), p.to_string()))
4470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4471            ),
4472            _ => local_var_req_builder.query(&[(
4473                "email__nic",
4474                &local_var_str
4475                    .into_iter()
4476                    .map(|p| p.to_string())
4477                    .collect::<Vec<String>>()
4478                    .join(",")
4479                    .to_string(),
4480            )]),
4481        };
4482    }
4483    if let Some(ref local_var_str) = email__nie {
4484        local_var_req_builder = match "multi" {
4485            "multi" => local_var_req_builder.query(
4486                &local_var_str
4487                    .into_iter()
4488                    .map(|p| ("email__nie".to_owned(), p.to_string()))
4489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4490            ),
4491            _ => local_var_req_builder.query(&[(
4492                "email__nie",
4493                &local_var_str
4494                    .into_iter()
4495                    .map(|p| p.to_string())
4496                    .collect::<Vec<String>>()
4497                    .join(",")
4498                    .to_string(),
4499            )]),
4500        };
4501    }
4502    if let Some(ref local_var_str) = email__niew {
4503        local_var_req_builder = match "multi" {
4504            "multi" => local_var_req_builder.query(
4505                &local_var_str
4506                    .into_iter()
4507                    .map(|p| ("email__niew".to_owned(), p.to_string()))
4508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4509            ),
4510            _ => local_var_req_builder.query(&[(
4511                "email__niew",
4512                &local_var_str
4513                    .into_iter()
4514                    .map(|p| p.to_string())
4515                    .collect::<Vec<String>>()
4516                    .join(",")
4517                    .to_string(),
4518            )]),
4519        };
4520    }
4521    if let Some(ref local_var_str) = email__nire {
4522        local_var_req_builder = match "multi" {
4523            "multi" => local_var_req_builder.query(
4524                &local_var_str
4525                    .into_iter()
4526                    .map(|p| ("email__nire".to_owned(), p.to_string()))
4527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4528            ),
4529            _ => local_var_req_builder.query(&[(
4530                "email__nire",
4531                &local_var_str
4532                    .into_iter()
4533                    .map(|p| p.to_string())
4534                    .collect::<Vec<String>>()
4535                    .join(",")
4536                    .to_string(),
4537            )]),
4538        };
4539    }
4540    if let Some(ref local_var_str) = email__nisw {
4541        local_var_req_builder = match "multi" {
4542            "multi" => local_var_req_builder.query(
4543                &local_var_str
4544                    .into_iter()
4545                    .map(|p| ("email__nisw".to_owned(), p.to_string()))
4546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4547            ),
4548            _ => local_var_req_builder.query(&[(
4549                "email__nisw",
4550                &local_var_str
4551                    .into_iter()
4552                    .map(|p| p.to_string())
4553                    .collect::<Vec<String>>()
4554                    .join(",")
4555                    .to_string(),
4556            )]),
4557        };
4558    }
4559    if let Some(ref local_var_str) = email__nre {
4560        local_var_req_builder = match "multi" {
4561            "multi" => local_var_req_builder.query(
4562                &local_var_str
4563                    .into_iter()
4564                    .map(|p| ("email__nre".to_owned(), p.to_string()))
4565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4566            ),
4567            _ => local_var_req_builder.query(&[(
4568                "email__nre",
4569                &local_var_str
4570                    .into_iter()
4571                    .map(|p| p.to_string())
4572                    .collect::<Vec<String>>()
4573                    .join(",")
4574                    .to_string(),
4575            )]),
4576        };
4577    }
4578    if let Some(ref local_var_str) = email__re {
4579        local_var_req_builder = match "multi" {
4580            "multi" => local_var_req_builder.query(
4581                &local_var_str
4582                    .into_iter()
4583                    .map(|p| ("email__re".to_owned(), p.to_string()))
4584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4585            ),
4586            _ => local_var_req_builder.query(&[(
4587                "email__re",
4588                &local_var_str
4589                    .into_iter()
4590                    .map(|p| p.to_string())
4591                    .collect::<Vec<String>>()
4592                    .join(",")
4593                    .to_string(),
4594            )]),
4595        };
4596    }
4597    if let Some(ref local_var_str) = first_name {
4598        local_var_req_builder = match "multi" {
4599            "multi" => local_var_req_builder.query(
4600                &local_var_str
4601                    .into_iter()
4602                    .map(|p| ("first_name".to_owned(), p.to_string()))
4603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4604            ),
4605            _ => local_var_req_builder.query(&[(
4606                "first_name",
4607                &local_var_str
4608                    .into_iter()
4609                    .map(|p| p.to_string())
4610                    .collect::<Vec<String>>()
4611                    .join(",")
4612                    .to_string(),
4613            )]),
4614        };
4615    }
4616    if let Some(ref local_var_str) = first_name__ic {
4617        local_var_req_builder = match "multi" {
4618            "multi" => local_var_req_builder.query(
4619                &local_var_str
4620                    .into_iter()
4621                    .map(|p| ("first_name__ic".to_owned(), p.to_string()))
4622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4623            ),
4624            _ => local_var_req_builder.query(&[(
4625                "first_name__ic",
4626                &local_var_str
4627                    .into_iter()
4628                    .map(|p| p.to_string())
4629                    .collect::<Vec<String>>()
4630                    .join(",")
4631                    .to_string(),
4632            )]),
4633        };
4634    }
4635    if let Some(ref local_var_str) = first_name__ie {
4636        local_var_req_builder = match "multi" {
4637            "multi" => local_var_req_builder.query(
4638                &local_var_str
4639                    .into_iter()
4640                    .map(|p| ("first_name__ie".to_owned(), p.to_string()))
4641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4642            ),
4643            _ => local_var_req_builder.query(&[(
4644                "first_name__ie",
4645                &local_var_str
4646                    .into_iter()
4647                    .map(|p| p.to_string())
4648                    .collect::<Vec<String>>()
4649                    .join(",")
4650                    .to_string(),
4651            )]),
4652        };
4653    }
4654    if let Some(ref local_var_str) = first_name__iew {
4655        local_var_req_builder = match "multi" {
4656            "multi" => local_var_req_builder.query(
4657                &local_var_str
4658                    .into_iter()
4659                    .map(|p| ("first_name__iew".to_owned(), p.to_string()))
4660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4661            ),
4662            _ => local_var_req_builder.query(&[(
4663                "first_name__iew",
4664                &local_var_str
4665                    .into_iter()
4666                    .map(|p| p.to_string())
4667                    .collect::<Vec<String>>()
4668                    .join(",")
4669                    .to_string(),
4670            )]),
4671        };
4672    }
4673    if let Some(ref local_var_str) = first_name__ire {
4674        local_var_req_builder = match "multi" {
4675            "multi" => local_var_req_builder.query(
4676                &local_var_str
4677                    .into_iter()
4678                    .map(|p| ("first_name__ire".to_owned(), p.to_string()))
4679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4680            ),
4681            _ => local_var_req_builder.query(&[(
4682                "first_name__ire",
4683                &local_var_str
4684                    .into_iter()
4685                    .map(|p| p.to_string())
4686                    .collect::<Vec<String>>()
4687                    .join(",")
4688                    .to_string(),
4689            )]),
4690        };
4691    }
4692    if let Some(ref local_var_str) = first_name__isw {
4693        local_var_req_builder = match "multi" {
4694            "multi" => local_var_req_builder.query(
4695                &local_var_str
4696                    .into_iter()
4697                    .map(|p| ("first_name__isw".to_owned(), p.to_string()))
4698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4699            ),
4700            _ => local_var_req_builder.query(&[(
4701                "first_name__isw",
4702                &local_var_str
4703                    .into_iter()
4704                    .map(|p| p.to_string())
4705                    .collect::<Vec<String>>()
4706                    .join(",")
4707                    .to_string(),
4708            )]),
4709        };
4710    }
4711    if let Some(ref local_var_str) = first_name__n {
4712        local_var_req_builder = match "multi" {
4713            "multi" => local_var_req_builder.query(
4714                &local_var_str
4715                    .into_iter()
4716                    .map(|p| ("first_name__n".to_owned(), p.to_string()))
4717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4718            ),
4719            _ => local_var_req_builder.query(&[(
4720                "first_name__n",
4721                &local_var_str
4722                    .into_iter()
4723                    .map(|p| p.to_string())
4724                    .collect::<Vec<String>>()
4725                    .join(",")
4726                    .to_string(),
4727            )]),
4728        };
4729    }
4730    if let Some(ref local_var_str) = first_name__nic {
4731        local_var_req_builder = match "multi" {
4732            "multi" => local_var_req_builder.query(
4733                &local_var_str
4734                    .into_iter()
4735                    .map(|p| ("first_name__nic".to_owned(), p.to_string()))
4736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4737            ),
4738            _ => local_var_req_builder.query(&[(
4739                "first_name__nic",
4740                &local_var_str
4741                    .into_iter()
4742                    .map(|p| p.to_string())
4743                    .collect::<Vec<String>>()
4744                    .join(",")
4745                    .to_string(),
4746            )]),
4747        };
4748    }
4749    if let Some(ref local_var_str) = first_name__nie {
4750        local_var_req_builder = match "multi" {
4751            "multi" => local_var_req_builder.query(
4752                &local_var_str
4753                    .into_iter()
4754                    .map(|p| ("first_name__nie".to_owned(), p.to_string()))
4755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4756            ),
4757            _ => local_var_req_builder.query(&[(
4758                "first_name__nie",
4759                &local_var_str
4760                    .into_iter()
4761                    .map(|p| p.to_string())
4762                    .collect::<Vec<String>>()
4763                    .join(",")
4764                    .to_string(),
4765            )]),
4766        };
4767    }
4768    if let Some(ref local_var_str) = first_name__niew {
4769        local_var_req_builder = match "multi" {
4770            "multi" => local_var_req_builder.query(
4771                &local_var_str
4772                    .into_iter()
4773                    .map(|p| ("first_name__niew".to_owned(), p.to_string()))
4774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4775            ),
4776            _ => local_var_req_builder.query(&[(
4777                "first_name__niew",
4778                &local_var_str
4779                    .into_iter()
4780                    .map(|p| p.to_string())
4781                    .collect::<Vec<String>>()
4782                    .join(",")
4783                    .to_string(),
4784            )]),
4785        };
4786    }
4787    if let Some(ref local_var_str) = first_name__nire {
4788        local_var_req_builder = match "multi" {
4789            "multi" => local_var_req_builder.query(
4790                &local_var_str
4791                    .into_iter()
4792                    .map(|p| ("first_name__nire".to_owned(), p.to_string()))
4793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4794            ),
4795            _ => local_var_req_builder.query(&[(
4796                "first_name__nire",
4797                &local_var_str
4798                    .into_iter()
4799                    .map(|p| p.to_string())
4800                    .collect::<Vec<String>>()
4801                    .join(",")
4802                    .to_string(),
4803            )]),
4804        };
4805    }
4806    if let Some(ref local_var_str) = first_name__nisw {
4807        local_var_req_builder = match "multi" {
4808            "multi" => local_var_req_builder.query(
4809                &local_var_str
4810                    .into_iter()
4811                    .map(|p| ("first_name__nisw".to_owned(), p.to_string()))
4812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4813            ),
4814            _ => local_var_req_builder.query(&[(
4815                "first_name__nisw",
4816                &local_var_str
4817                    .into_iter()
4818                    .map(|p| p.to_string())
4819                    .collect::<Vec<String>>()
4820                    .join(",")
4821                    .to_string(),
4822            )]),
4823        };
4824    }
4825    if let Some(ref local_var_str) = first_name__nre {
4826        local_var_req_builder = match "multi" {
4827            "multi" => local_var_req_builder.query(
4828                &local_var_str
4829                    .into_iter()
4830                    .map(|p| ("first_name__nre".to_owned(), p.to_string()))
4831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4832            ),
4833            _ => local_var_req_builder.query(&[(
4834                "first_name__nre",
4835                &local_var_str
4836                    .into_iter()
4837                    .map(|p| p.to_string())
4838                    .collect::<Vec<String>>()
4839                    .join(",")
4840                    .to_string(),
4841            )]),
4842        };
4843    }
4844    if let Some(ref local_var_str) = first_name__re {
4845        local_var_req_builder = match "multi" {
4846            "multi" => local_var_req_builder.query(
4847                &local_var_str
4848                    .into_iter()
4849                    .map(|p| ("first_name__re".to_owned(), p.to_string()))
4850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4851            ),
4852            _ => local_var_req_builder.query(&[(
4853                "first_name__re",
4854                &local_var_str
4855                    .into_iter()
4856                    .map(|p| p.to_string())
4857                    .collect::<Vec<String>>()
4858                    .join(",")
4859                    .to_string(),
4860            )]),
4861        };
4862    }
4863    if let Some(ref local_var_str) = format {
4864        local_var_req_builder =
4865            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4866    }
4867    if let Some(ref local_var_str) = groups {
4868        local_var_req_builder = match "multi" {
4869            "multi" => local_var_req_builder.query(
4870                &local_var_str
4871                    .into_iter()
4872                    .map(|p| ("groups".to_owned(), p.to_string()))
4873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4874            ),
4875            _ => local_var_req_builder.query(&[(
4876                "groups",
4877                &local_var_str
4878                    .into_iter()
4879                    .map(|p| p.to_string())
4880                    .collect::<Vec<String>>()
4881                    .join(",")
4882                    .to_string(),
4883            )]),
4884        };
4885    }
4886    if let Some(ref local_var_str) = groups__n {
4887        local_var_req_builder = match "multi" {
4888            "multi" => local_var_req_builder.query(
4889                &local_var_str
4890                    .into_iter()
4891                    .map(|p| ("groups__n".to_owned(), p.to_string()))
4892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4893            ),
4894            _ => local_var_req_builder.query(&[(
4895                "groups__n",
4896                &local_var_str
4897                    .into_iter()
4898                    .map(|p| p.to_string())
4899                    .collect::<Vec<String>>()
4900                    .join(",")
4901                    .to_string(),
4902            )]),
4903        };
4904    }
4905    if let Some(ref local_var_str) = groups_id {
4906        local_var_req_builder = match "multi" {
4907            "multi" => local_var_req_builder.query(
4908                &local_var_str
4909                    .into_iter()
4910                    .map(|p| ("groups_id".to_owned(), p.to_string()))
4911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4912            ),
4913            _ => local_var_req_builder.query(&[(
4914                "groups_id",
4915                &local_var_str
4916                    .into_iter()
4917                    .map(|p| p.to_string())
4918                    .collect::<Vec<String>>()
4919                    .join(",")
4920                    .to_string(),
4921            )]),
4922        };
4923    }
4924    if let Some(ref local_var_str) = groups_id__n {
4925        local_var_req_builder = match "multi" {
4926            "multi" => local_var_req_builder.query(
4927                &local_var_str
4928                    .into_iter()
4929                    .map(|p| ("groups_id__n".to_owned(), p.to_string()))
4930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4931            ),
4932            _ => local_var_req_builder.query(&[(
4933                "groups_id__n",
4934                &local_var_str
4935                    .into_iter()
4936                    .map(|p| p.to_string())
4937                    .collect::<Vec<String>>()
4938                    .join(",")
4939                    .to_string(),
4940            )]),
4941        };
4942    }
4943    if let Some(ref local_var_str) = has_object_changes {
4944        local_var_req_builder =
4945            local_var_req_builder.query(&[("has_object_changes", &local_var_str.to_string())]);
4946    }
4947    if let Some(ref local_var_str) = has_object_permissions {
4948        local_var_req_builder =
4949            local_var_req_builder.query(&[("has_object_permissions", &local_var_str.to_string())]);
4950    }
4951    if let Some(ref local_var_str) = has_rack_reservations {
4952        local_var_req_builder =
4953            local_var_req_builder.query(&[("has_rack_reservations", &local_var_str.to_string())]);
4954    }
4955    if let Some(ref local_var_str) = id {
4956        local_var_req_builder = match "multi" {
4957            "multi" => local_var_req_builder.query(
4958                &local_var_str
4959                    .into_iter()
4960                    .map(|p| ("id".to_owned(), p.to_string()))
4961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4962            ),
4963            _ => local_var_req_builder.query(&[(
4964                "id",
4965                &local_var_str
4966                    .into_iter()
4967                    .map(|p| p.to_string())
4968                    .collect::<Vec<String>>()
4969                    .join(",")
4970                    .to_string(),
4971            )]),
4972        };
4973    }
4974    if let Some(ref local_var_str) = id__n {
4975        local_var_req_builder = match "multi" {
4976            "multi" => local_var_req_builder.query(
4977                &local_var_str
4978                    .into_iter()
4979                    .map(|p| ("id__n".to_owned(), p.to_string()))
4980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4981            ),
4982            _ => local_var_req_builder.query(&[(
4983                "id__n",
4984                &local_var_str
4985                    .into_iter()
4986                    .map(|p| p.to_string())
4987                    .collect::<Vec<String>>()
4988                    .join(",")
4989                    .to_string(),
4990            )]),
4991        };
4992    }
4993    if let Some(ref local_var_str) = is_active {
4994        local_var_req_builder =
4995            local_var_req_builder.query(&[("is_active", &local_var_str.to_string())]);
4996    }
4997    if let Some(ref local_var_str) = is_staff {
4998        local_var_req_builder =
4999            local_var_req_builder.query(&[("is_staff", &local_var_str.to_string())]);
5000    }
5001    if let Some(ref local_var_str) = last_name {
5002        local_var_req_builder = match "multi" {
5003            "multi" => local_var_req_builder.query(
5004                &local_var_str
5005                    .into_iter()
5006                    .map(|p| ("last_name".to_owned(), p.to_string()))
5007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5008            ),
5009            _ => local_var_req_builder.query(&[(
5010                "last_name",
5011                &local_var_str
5012                    .into_iter()
5013                    .map(|p| p.to_string())
5014                    .collect::<Vec<String>>()
5015                    .join(",")
5016                    .to_string(),
5017            )]),
5018        };
5019    }
5020    if let Some(ref local_var_str) = last_name__ic {
5021        local_var_req_builder = match "multi" {
5022            "multi" => local_var_req_builder.query(
5023                &local_var_str
5024                    .into_iter()
5025                    .map(|p| ("last_name__ic".to_owned(), p.to_string()))
5026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5027            ),
5028            _ => local_var_req_builder.query(&[(
5029                "last_name__ic",
5030                &local_var_str
5031                    .into_iter()
5032                    .map(|p| p.to_string())
5033                    .collect::<Vec<String>>()
5034                    .join(",")
5035                    .to_string(),
5036            )]),
5037        };
5038    }
5039    if let Some(ref local_var_str) = last_name__ie {
5040        local_var_req_builder = match "multi" {
5041            "multi" => local_var_req_builder.query(
5042                &local_var_str
5043                    .into_iter()
5044                    .map(|p| ("last_name__ie".to_owned(), p.to_string()))
5045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5046            ),
5047            _ => local_var_req_builder.query(&[(
5048                "last_name__ie",
5049                &local_var_str
5050                    .into_iter()
5051                    .map(|p| p.to_string())
5052                    .collect::<Vec<String>>()
5053                    .join(",")
5054                    .to_string(),
5055            )]),
5056        };
5057    }
5058    if let Some(ref local_var_str) = last_name__iew {
5059        local_var_req_builder = match "multi" {
5060            "multi" => local_var_req_builder.query(
5061                &local_var_str
5062                    .into_iter()
5063                    .map(|p| ("last_name__iew".to_owned(), p.to_string()))
5064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5065            ),
5066            _ => local_var_req_builder.query(&[(
5067                "last_name__iew",
5068                &local_var_str
5069                    .into_iter()
5070                    .map(|p| p.to_string())
5071                    .collect::<Vec<String>>()
5072                    .join(",")
5073                    .to_string(),
5074            )]),
5075        };
5076    }
5077    if let Some(ref local_var_str) = last_name__ire {
5078        local_var_req_builder = match "multi" {
5079            "multi" => local_var_req_builder.query(
5080                &local_var_str
5081                    .into_iter()
5082                    .map(|p| ("last_name__ire".to_owned(), p.to_string()))
5083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5084            ),
5085            _ => local_var_req_builder.query(&[(
5086                "last_name__ire",
5087                &local_var_str
5088                    .into_iter()
5089                    .map(|p| p.to_string())
5090                    .collect::<Vec<String>>()
5091                    .join(",")
5092                    .to_string(),
5093            )]),
5094        };
5095    }
5096    if let Some(ref local_var_str) = last_name__isw {
5097        local_var_req_builder = match "multi" {
5098            "multi" => local_var_req_builder.query(
5099                &local_var_str
5100                    .into_iter()
5101                    .map(|p| ("last_name__isw".to_owned(), p.to_string()))
5102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5103            ),
5104            _ => local_var_req_builder.query(&[(
5105                "last_name__isw",
5106                &local_var_str
5107                    .into_iter()
5108                    .map(|p| p.to_string())
5109                    .collect::<Vec<String>>()
5110                    .join(",")
5111                    .to_string(),
5112            )]),
5113        };
5114    }
5115    if let Some(ref local_var_str) = last_name__n {
5116        local_var_req_builder = match "multi" {
5117            "multi" => local_var_req_builder.query(
5118                &local_var_str
5119                    .into_iter()
5120                    .map(|p| ("last_name__n".to_owned(), p.to_string()))
5121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5122            ),
5123            _ => local_var_req_builder.query(&[(
5124                "last_name__n",
5125                &local_var_str
5126                    .into_iter()
5127                    .map(|p| p.to_string())
5128                    .collect::<Vec<String>>()
5129                    .join(",")
5130                    .to_string(),
5131            )]),
5132        };
5133    }
5134    if let Some(ref local_var_str) = last_name__nic {
5135        local_var_req_builder = match "multi" {
5136            "multi" => local_var_req_builder.query(
5137                &local_var_str
5138                    .into_iter()
5139                    .map(|p| ("last_name__nic".to_owned(), p.to_string()))
5140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5141            ),
5142            _ => local_var_req_builder.query(&[(
5143                "last_name__nic",
5144                &local_var_str
5145                    .into_iter()
5146                    .map(|p| p.to_string())
5147                    .collect::<Vec<String>>()
5148                    .join(",")
5149                    .to_string(),
5150            )]),
5151        };
5152    }
5153    if let Some(ref local_var_str) = last_name__nie {
5154        local_var_req_builder = match "multi" {
5155            "multi" => local_var_req_builder.query(
5156                &local_var_str
5157                    .into_iter()
5158                    .map(|p| ("last_name__nie".to_owned(), p.to_string()))
5159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5160            ),
5161            _ => local_var_req_builder.query(&[(
5162                "last_name__nie",
5163                &local_var_str
5164                    .into_iter()
5165                    .map(|p| p.to_string())
5166                    .collect::<Vec<String>>()
5167                    .join(",")
5168                    .to_string(),
5169            )]),
5170        };
5171    }
5172    if let Some(ref local_var_str) = last_name__niew {
5173        local_var_req_builder = match "multi" {
5174            "multi" => local_var_req_builder.query(
5175                &local_var_str
5176                    .into_iter()
5177                    .map(|p| ("last_name__niew".to_owned(), p.to_string()))
5178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5179            ),
5180            _ => local_var_req_builder.query(&[(
5181                "last_name__niew",
5182                &local_var_str
5183                    .into_iter()
5184                    .map(|p| p.to_string())
5185                    .collect::<Vec<String>>()
5186                    .join(",")
5187                    .to_string(),
5188            )]),
5189        };
5190    }
5191    if let Some(ref local_var_str) = last_name__nire {
5192        local_var_req_builder = match "multi" {
5193            "multi" => local_var_req_builder.query(
5194                &local_var_str
5195                    .into_iter()
5196                    .map(|p| ("last_name__nire".to_owned(), p.to_string()))
5197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5198            ),
5199            _ => local_var_req_builder.query(&[(
5200                "last_name__nire",
5201                &local_var_str
5202                    .into_iter()
5203                    .map(|p| p.to_string())
5204                    .collect::<Vec<String>>()
5205                    .join(",")
5206                    .to_string(),
5207            )]),
5208        };
5209    }
5210    if let Some(ref local_var_str) = last_name__nisw {
5211        local_var_req_builder = match "multi" {
5212            "multi" => local_var_req_builder.query(
5213                &local_var_str
5214                    .into_iter()
5215                    .map(|p| ("last_name__nisw".to_owned(), p.to_string()))
5216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5217            ),
5218            _ => local_var_req_builder.query(&[(
5219                "last_name__nisw",
5220                &local_var_str
5221                    .into_iter()
5222                    .map(|p| p.to_string())
5223                    .collect::<Vec<String>>()
5224                    .join(",")
5225                    .to_string(),
5226            )]),
5227        };
5228    }
5229    if let Some(ref local_var_str) = last_name__nre {
5230        local_var_req_builder = match "multi" {
5231            "multi" => local_var_req_builder.query(
5232                &local_var_str
5233                    .into_iter()
5234                    .map(|p| ("last_name__nre".to_owned(), p.to_string()))
5235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5236            ),
5237            _ => local_var_req_builder.query(&[(
5238                "last_name__nre",
5239                &local_var_str
5240                    .into_iter()
5241                    .map(|p| p.to_string())
5242                    .collect::<Vec<String>>()
5243                    .join(",")
5244                    .to_string(),
5245            )]),
5246        };
5247    }
5248    if let Some(ref local_var_str) = last_name__re {
5249        local_var_req_builder = match "multi" {
5250            "multi" => local_var_req_builder.query(
5251                &local_var_str
5252                    .into_iter()
5253                    .map(|p| ("last_name__re".to_owned(), p.to_string()))
5254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5255            ),
5256            _ => local_var_req_builder.query(&[(
5257                "last_name__re",
5258                &local_var_str
5259                    .into_iter()
5260                    .map(|p| p.to_string())
5261                    .collect::<Vec<String>>()
5262                    .join(",")
5263                    .to_string(),
5264            )]),
5265        };
5266    }
5267    if let Some(ref local_var_str) = limit {
5268        local_var_req_builder =
5269            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5270    }
5271    if let Some(ref local_var_str) = object_changes {
5272        local_var_req_builder = match "multi" {
5273            "multi" => local_var_req_builder.query(
5274                &local_var_str
5275                    .into_iter()
5276                    .map(|p| ("object_changes".to_owned(), p.to_string()))
5277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5278            ),
5279            _ => local_var_req_builder.query(&[(
5280                "object_changes",
5281                &local_var_str
5282                    .into_iter()
5283                    .map(|p| p.to_string())
5284                    .collect::<Vec<String>>()
5285                    .join(",")
5286                    .to_string(),
5287            )]),
5288        };
5289    }
5290    if let Some(ref local_var_str) = object_changes__isnull {
5291        local_var_req_builder =
5292            local_var_req_builder.query(&[("object_changes__isnull", &local_var_str.to_string())]);
5293    }
5294    if let Some(ref local_var_str) = object_changes__n {
5295        local_var_req_builder = match "multi" {
5296            "multi" => local_var_req_builder.query(
5297                &local_var_str
5298                    .into_iter()
5299                    .map(|p| ("object_changes__n".to_owned(), p.to_string()))
5300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5301            ),
5302            _ => local_var_req_builder.query(&[(
5303                "object_changes__n",
5304                &local_var_str
5305                    .into_iter()
5306                    .map(|p| p.to_string())
5307                    .collect::<Vec<String>>()
5308                    .join(",")
5309                    .to_string(),
5310            )]),
5311        };
5312    }
5313    if let Some(ref local_var_str) = object_permissions {
5314        local_var_req_builder = match "multi" {
5315            "multi" => local_var_req_builder.query(
5316                &local_var_str
5317                    .into_iter()
5318                    .map(|p| ("object_permissions".to_owned(), p.to_string()))
5319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5320            ),
5321            _ => local_var_req_builder.query(&[(
5322                "object_permissions",
5323                &local_var_str
5324                    .into_iter()
5325                    .map(|p| p.to_string())
5326                    .collect::<Vec<String>>()
5327                    .join(",")
5328                    .to_string(),
5329            )]),
5330        };
5331    }
5332    if let Some(ref local_var_str) = object_permissions__isnull {
5333        local_var_req_builder = local_var_req_builder
5334            .query(&[("object_permissions__isnull", &local_var_str.to_string())]);
5335    }
5336    if let Some(ref local_var_str) = object_permissions__n {
5337        local_var_req_builder = match "multi" {
5338            "multi" => local_var_req_builder.query(
5339                &local_var_str
5340                    .into_iter()
5341                    .map(|p| ("object_permissions__n".to_owned(), p.to_string()))
5342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5343            ),
5344            _ => local_var_req_builder.query(&[(
5345                "object_permissions__n",
5346                &local_var_str
5347                    .into_iter()
5348                    .map(|p| p.to_string())
5349                    .collect::<Vec<String>>()
5350                    .join(",")
5351                    .to_string(),
5352            )]),
5353        };
5354    }
5355    if let Some(ref local_var_str) = offset {
5356        local_var_req_builder =
5357            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5358    }
5359    if let Some(ref local_var_str) = q {
5360        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5361    }
5362    if let Some(ref local_var_str) = rack_reservations_id {
5363        local_var_req_builder = match "multi" {
5364            "multi" => local_var_req_builder.query(
5365                &local_var_str
5366                    .into_iter()
5367                    .map(|p| ("rack_reservations_id".to_owned(), p.to_string()))
5368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5369            ),
5370            _ => local_var_req_builder.query(&[(
5371                "rack_reservations_id",
5372                &local_var_str
5373                    .into_iter()
5374                    .map(|p| p.to_string())
5375                    .collect::<Vec<String>>()
5376                    .join(",")
5377                    .to_string(),
5378            )]),
5379        };
5380    }
5381    if let Some(ref local_var_str) = rack_reservations_id__isnull {
5382        local_var_req_builder = local_var_req_builder
5383            .query(&[("rack_reservations_id__isnull", &local_var_str.to_string())]);
5384    }
5385    if let Some(ref local_var_str) = rack_reservations_id__n {
5386        local_var_req_builder = match "multi" {
5387            "multi" => local_var_req_builder.query(
5388                &local_var_str
5389                    .into_iter()
5390                    .map(|p| ("rack_reservations_id__n".to_owned(), p.to_string()))
5391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5392            ),
5393            _ => local_var_req_builder.query(&[(
5394                "rack_reservations_id__n",
5395                &local_var_str
5396                    .into_iter()
5397                    .map(|p| p.to_string())
5398                    .collect::<Vec<String>>()
5399                    .join(",")
5400                    .to_string(),
5401            )]),
5402        };
5403    }
5404    if let Some(ref local_var_str) = sort {
5405        local_var_req_builder =
5406            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
5407    }
5408    if let Some(ref local_var_str) = username {
5409        local_var_req_builder = match "multi" {
5410            "multi" => local_var_req_builder.query(
5411                &local_var_str
5412                    .into_iter()
5413                    .map(|p| ("username".to_owned(), p.to_string()))
5414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5415            ),
5416            _ => local_var_req_builder.query(&[(
5417                "username",
5418                &local_var_str
5419                    .into_iter()
5420                    .map(|p| p.to_string())
5421                    .collect::<Vec<String>>()
5422                    .join(",")
5423                    .to_string(),
5424            )]),
5425        };
5426    }
5427    if let Some(ref local_var_str) = username__ic {
5428        local_var_req_builder = match "multi" {
5429            "multi" => local_var_req_builder.query(
5430                &local_var_str
5431                    .into_iter()
5432                    .map(|p| ("username__ic".to_owned(), p.to_string()))
5433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5434            ),
5435            _ => local_var_req_builder.query(&[(
5436                "username__ic",
5437                &local_var_str
5438                    .into_iter()
5439                    .map(|p| p.to_string())
5440                    .collect::<Vec<String>>()
5441                    .join(",")
5442                    .to_string(),
5443            )]),
5444        };
5445    }
5446    if let Some(ref local_var_str) = username__ie {
5447        local_var_req_builder = match "multi" {
5448            "multi" => local_var_req_builder.query(
5449                &local_var_str
5450                    .into_iter()
5451                    .map(|p| ("username__ie".to_owned(), p.to_string()))
5452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5453            ),
5454            _ => local_var_req_builder.query(&[(
5455                "username__ie",
5456                &local_var_str
5457                    .into_iter()
5458                    .map(|p| p.to_string())
5459                    .collect::<Vec<String>>()
5460                    .join(",")
5461                    .to_string(),
5462            )]),
5463        };
5464    }
5465    if let Some(ref local_var_str) = username__iew {
5466        local_var_req_builder = match "multi" {
5467            "multi" => local_var_req_builder.query(
5468                &local_var_str
5469                    .into_iter()
5470                    .map(|p| ("username__iew".to_owned(), p.to_string()))
5471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5472            ),
5473            _ => local_var_req_builder.query(&[(
5474                "username__iew",
5475                &local_var_str
5476                    .into_iter()
5477                    .map(|p| p.to_string())
5478                    .collect::<Vec<String>>()
5479                    .join(",")
5480                    .to_string(),
5481            )]),
5482        };
5483    }
5484    if let Some(ref local_var_str) = username__ire {
5485        local_var_req_builder = match "multi" {
5486            "multi" => local_var_req_builder.query(
5487                &local_var_str
5488                    .into_iter()
5489                    .map(|p| ("username__ire".to_owned(), p.to_string()))
5490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5491            ),
5492            _ => local_var_req_builder.query(&[(
5493                "username__ire",
5494                &local_var_str
5495                    .into_iter()
5496                    .map(|p| p.to_string())
5497                    .collect::<Vec<String>>()
5498                    .join(",")
5499                    .to_string(),
5500            )]),
5501        };
5502    }
5503    if let Some(ref local_var_str) = username__isw {
5504        local_var_req_builder = match "multi" {
5505            "multi" => local_var_req_builder.query(
5506                &local_var_str
5507                    .into_iter()
5508                    .map(|p| ("username__isw".to_owned(), p.to_string()))
5509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5510            ),
5511            _ => local_var_req_builder.query(&[(
5512                "username__isw",
5513                &local_var_str
5514                    .into_iter()
5515                    .map(|p| p.to_string())
5516                    .collect::<Vec<String>>()
5517                    .join(",")
5518                    .to_string(),
5519            )]),
5520        };
5521    }
5522    if let Some(ref local_var_str) = username__n {
5523        local_var_req_builder = match "multi" {
5524            "multi" => local_var_req_builder.query(
5525                &local_var_str
5526                    .into_iter()
5527                    .map(|p| ("username__n".to_owned(), p.to_string()))
5528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5529            ),
5530            _ => local_var_req_builder.query(&[(
5531                "username__n",
5532                &local_var_str
5533                    .into_iter()
5534                    .map(|p| p.to_string())
5535                    .collect::<Vec<String>>()
5536                    .join(",")
5537                    .to_string(),
5538            )]),
5539        };
5540    }
5541    if let Some(ref local_var_str) = username__nic {
5542        local_var_req_builder = match "multi" {
5543            "multi" => local_var_req_builder.query(
5544                &local_var_str
5545                    .into_iter()
5546                    .map(|p| ("username__nic".to_owned(), p.to_string()))
5547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5548            ),
5549            _ => local_var_req_builder.query(&[(
5550                "username__nic",
5551                &local_var_str
5552                    .into_iter()
5553                    .map(|p| p.to_string())
5554                    .collect::<Vec<String>>()
5555                    .join(",")
5556                    .to_string(),
5557            )]),
5558        };
5559    }
5560    if let Some(ref local_var_str) = username__nie {
5561        local_var_req_builder = match "multi" {
5562            "multi" => local_var_req_builder.query(
5563                &local_var_str
5564                    .into_iter()
5565                    .map(|p| ("username__nie".to_owned(), p.to_string()))
5566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5567            ),
5568            _ => local_var_req_builder.query(&[(
5569                "username__nie",
5570                &local_var_str
5571                    .into_iter()
5572                    .map(|p| p.to_string())
5573                    .collect::<Vec<String>>()
5574                    .join(",")
5575                    .to_string(),
5576            )]),
5577        };
5578    }
5579    if let Some(ref local_var_str) = username__niew {
5580        local_var_req_builder = match "multi" {
5581            "multi" => local_var_req_builder.query(
5582                &local_var_str
5583                    .into_iter()
5584                    .map(|p| ("username__niew".to_owned(), p.to_string()))
5585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5586            ),
5587            _ => local_var_req_builder.query(&[(
5588                "username__niew",
5589                &local_var_str
5590                    .into_iter()
5591                    .map(|p| p.to_string())
5592                    .collect::<Vec<String>>()
5593                    .join(",")
5594                    .to_string(),
5595            )]),
5596        };
5597    }
5598    if let Some(ref local_var_str) = username__nire {
5599        local_var_req_builder = match "multi" {
5600            "multi" => local_var_req_builder.query(
5601                &local_var_str
5602                    .into_iter()
5603                    .map(|p| ("username__nire".to_owned(), p.to_string()))
5604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5605            ),
5606            _ => local_var_req_builder.query(&[(
5607                "username__nire",
5608                &local_var_str
5609                    .into_iter()
5610                    .map(|p| p.to_string())
5611                    .collect::<Vec<String>>()
5612                    .join(",")
5613                    .to_string(),
5614            )]),
5615        };
5616    }
5617    if let Some(ref local_var_str) = username__nisw {
5618        local_var_req_builder = match "multi" {
5619            "multi" => local_var_req_builder.query(
5620                &local_var_str
5621                    .into_iter()
5622                    .map(|p| ("username__nisw".to_owned(), p.to_string()))
5623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5624            ),
5625            _ => local_var_req_builder.query(&[(
5626                "username__nisw",
5627                &local_var_str
5628                    .into_iter()
5629                    .map(|p| p.to_string())
5630                    .collect::<Vec<String>>()
5631                    .join(",")
5632                    .to_string(),
5633            )]),
5634        };
5635    }
5636    if let Some(ref local_var_str) = username__nre {
5637        local_var_req_builder = match "multi" {
5638            "multi" => local_var_req_builder.query(
5639                &local_var_str
5640                    .into_iter()
5641                    .map(|p| ("username__nre".to_owned(), p.to_string()))
5642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5643            ),
5644            _ => local_var_req_builder.query(&[(
5645                "username__nre",
5646                &local_var_str
5647                    .into_iter()
5648                    .map(|p| p.to_string())
5649                    .collect::<Vec<String>>()
5650                    .join(",")
5651                    .to_string(),
5652            )]),
5653        };
5654    }
5655    if let Some(ref local_var_str) = username__re {
5656        local_var_req_builder = match "multi" {
5657            "multi" => local_var_req_builder.query(
5658                &local_var_str
5659                    .into_iter()
5660                    .map(|p| ("username__re".to_owned(), p.to_string()))
5661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5662            ),
5663            _ => local_var_req_builder.query(&[(
5664                "username__re",
5665                &local_var_str
5666                    .into_iter()
5667                    .map(|p| p.to_string())
5668                    .collect::<Vec<String>>()
5669                    .join(",")
5670                    .to_string(),
5671            )]),
5672        };
5673    }
5674    if let Some(ref local_var_str) = depth {
5675        local_var_req_builder =
5676            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5677    }
5678    if let Some(ref local_var_str) = exclude_m2m {
5679        local_var_req_builder =
5680            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5681    }
5682    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5683        local_var_req_builder =
5684            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5685    }
5686    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5687        let local_var_key = local_var_apikey.key.clone();
5688        let local_var_value = match local_var_apikey.prefix {
5689            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5690            None => local_var_key,
5691        };
5692        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5693    };
5694
5695    let local_var_req = local_var_req_builder.build()?;
5696    let local_var_resp = local_var_client.execute(local_var_req).await?;
5697
5698    let local_var_status = local_var_resp.status();
5699    let local_var_content = local_var_resp.text().await?;
5700
5701    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5702        serde_json::from_str(&local_var_content).map_err(Error::from)
5703    } else {
5704        let local_var_entity: Option<UsersUsersListError> =
5705            serde_json::from_str(&local_var_content).ok();
5706        let local_var_error = ResponseContent {
5707            status: local_var_status,
5708            content: local_var_content,
5709            entity: local_var_entity,
5710        };
5711        Err(Error::ResponseError(local_var_error))
5712    }
5713}
5714
5715/// Partial update a user object.
5716pub async fn users_users_partial_update(
5717    configuration: &configuration::Configuration,
5718    id: &str,
5719    format: Option<&str>,
5720    patched_user_request: Option<crate::models::PatchedUserRequest>,
5721) -> Result<crate::models::User, Error<UsersUsersPartialUpdateError>> {
5722    let local_var_configuration = configuration;
5723
5724    let local_var_client = &local_var_configuration.client;
5725
5726    let local_var_uri_str = format!(
5727        "{}/users/users/{id}/",
5728        local_var_configuration.base_path,
5729        id = crate::apis::urlencode(id)
5730    );
5731    let mut local_var_req_builder =
5732        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5733
5734    if let Some(ref local_var_str) = format {
5735        local_var_req_builder =
5736            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5737    }
5738    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5739        local_var_req_builder =
5740            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5741    }
5742    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5743        let local_var_key = local_var_apikey.key.clone();
5744        let local_var_value = match local_var_apikey.prefix {
5745            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5746            None => local_var_key,
5747        };
5748        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5749    };
5750    local_var_req_builder = local_var_req_builder.json(&patched_user_request);
5751
5752    let local_var_req = local_var_req_builder.build()?;
5753    let local_var_resp = local_var_client.execute(local_var_req).await?;
5754
5755    let local_var_status = local_var_resp.status();
5756    let local_var_content = local_var_resp.text().await?;
5757
5758    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5759        serde_json::from_str(&local_var_content).map_err(Error::from)
5760    } else {
5761        let local_var_entity: Option<UsersUsersPartialUpdateError> =
5762            serde_json::from_str(&local_var_content).ok();
5763        let local_var_error = ResponseContent {
5764            status: local_var_status,
5765            content: local_var_content,
5766            entity: local_var_entity,
5767        };
5768        Err(Error::ResponseError(local_var_error))
5769    }
5770}
5771
5772/// Retrieve a user object.
5773pub async fn users_users_retrieve(
5774    configuration: &configuration::Configuration,
5775    id: &str,
5776    format: Option<&str>,
5777    depth: Option<i32>,
5778    exclude_m2m: Option<bool>,
5779) -> Result<crate::models::User, Error<UsersUsersRetrieveError>> {
5780    let local_var_configuration = configuration;
5781
5782    let local_var_client = &local_var_configuration.client;
5783
5784    let local_var_uri_str = format!(
5785        "{}/users/users/{id}/",
5786        local_var_configuration.base_path,
5787        id = crate::apis::urlencode(id)
5788    );
5789    let mut local_var_req_builder =
5790        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5791
5792    if let Some(ref local_var_str) = format {
5793        local_var_req_builder =
5794            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5795    }
5796    if let Some(ref local_var_str) = depth {
5797        local_var_req_builder =
5798            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5799    }
5800    if let Some(ref local_var_str) = exclude_m2m {
5801        local_var_req_builder =
5802            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5803    }
5804    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5805        local_var_req_builder =
5806            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5807    }
5808    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5809        let local_var_key = local_var_apikey.key.clone();
5810        let local_var_value = match local_var_apikey.prefix {
5811            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5812            None => local_var_key,
5813        };
5814        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5815    };
5816
5817    let local_var_req = local_var_req_builder.build()?;
5818    let local_var_resp = local_var_client.execute(local_var_req).await?;
5819
5820    let local_var_status = local_var_resp.status();
5821    let local_var_content = local_var_resp.text().await?;
5822
5823    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5824        serde_json::from_str(&local_var_content).map_err(Error::from)
5825    } else {
5826        let local_var_entity: Option<UsersUsersRetrieveError> =
5827            serde_json::from_str(&local_var_content).ok();
5828        let local_var_error = ResponseContent {
5829            status: local_var_status,
5830            content: local_var_content,
5831            entity: local_var_entity,
5832        };
5833        Err(Error::ResponseError(local_var_error))
5834    }
5835}
5836
5837/// Update a user object.
5838pub async fn users_users_update(
5839    configuration: &configuration::Configuration,
5840    id: &str,
5841    user_request: crate::models::UserRequest,
5842    format: Option<&str>,
5843) -> Result<crate::models::User, Error<UsersUsersUpdateError>> {
5844    let local_var_configuration = configuration;
5845
5846    let local_var_client = &local_var_configuration.client;
5847
5848    let local_var_uri_str = format!(
5849        "{}/users/users/{id}/",
5850        local_var_configuration.base_path,
5851        id = crate::apis::urlencode(id)
5852    );
5853    let mut local_var_req_builder =
5854        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5855
5856    if let Some(ref local_var_str) = format {
5857        local_var_req_builder =
5858            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5859    }
5860    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5861        local_var_req_builder =
5862            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5863    }
5864    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5865        let local_var_key = local_var_apikey.key.clone();
5866        let local_var_value = match local_var_apikey.prefix {
5867            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5868            None => local_var_key,
5869        };
5870        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5871    };
5872    local_var_req_builder = local_var_req_builder.json(&user_request);
5873
5874    let local_var_req = local_var_req_builder.build()?;
5875    let local_var_resp = local_var_client.execute(local_var_req).await?;
5876
5877    let local_var_status = local_var_resp.status();
5878    let local_var_content = local_var_resp.text().await?;
5879
5880    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5881        serde_json::from_str(&local_var_content).map_err(Error::from)
5882    } else {
5883        let local_var_entity: Option<UsersUsersUpdateError> =
5884            serde_json::from_str(&local_var_content).ok();
5885        let local_var_error = ResponseContent {
5886            status: local_var_status,
5887            content: local_var_content,
5888            entity: local_var_entity,
5889        };
5890        Err(Error::ResponseError(local_var_error))
5891    }
5892}
nautobot_openapi/apis/users_api.rs

nautobot_openapi/apis/
users_api.rs
