netbox_openapi/apis/
users_api.rs

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

netbox_openapi/apis/
users_api.rs
