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

netbox_openapi/apis/
users_api.rs
