netbox_openapi/apis/
core_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 [`core_background_queues_retrieve`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CoreBackgroundQueuesRetrieveError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`core_background_queues_retrieve_by_name`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum CoreBackgroundQueuesRetrieveByNameError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`core_background_tasks_delete_create`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum CoreBackgroundTasksDeleteCreateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`core_background_tasks_enqueue_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum CoreBackgroundTasksEnqueueCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`core_background_tasks_requeue_create`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum CoreBackgroundTasksRequeueCreateError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`core_background_tasks_retrieve`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum CoreBackgroundTasksRetrieveError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`core_background_tasks_retrieve_by_id`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum CoreBackgroundTasksRetrieveByIdError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`core_background_tasks_stop_create`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum CoreBackgroundTasksStopCreateError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`core_background_workers_retrieve`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum CoreBackgroundWorkersRetrieveError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`core_background_workers_retrieve_by_name`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum CoreBackgroundWorkersRetrieveByNameError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`core_data_files_list`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum CoreDataFilesListError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`core_data_files_retrieve`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum CoreDataFilesRetrieveError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`core_data_sources_bulk_destroy`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum CoreDataSourcesBulkDestroyError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`core_data_sources_bulk_partial_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum CoreDataSourcesBulkPartialUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`core_data_sources_bulk_update`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum CoreDataSourcesBulkUpdateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`core_data_sources_create`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum CoreDataSourcesCreateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`core_data_sources_destroy`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum CoreDataSourcesDestroyError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`core_data_sources_list`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum CoreDataSourcesListError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`core_data_sources_partial_update`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum CoreDataSourcesPartialUpdateError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`core_data_sources_retrieve`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum CoreDataSourcesRetrieveError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`core_data_sources_sync_create`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum CoreDataSourcesSyncCreateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`core_data_sources_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum CoreDataSourcesUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`core_jobs_list`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum CoreJobsListError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`core_jobs_retrieve`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum CoreJobsRetrieveError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`core_object_changes_list`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum CoreObjectChangesListError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`core_object_changes_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum CoreObjectChangesRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`core_object_types_list`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum CoreObjectTypesListError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`core_object_types_retrieve`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum CoreObjectTypesRetrieveError {
209    UnknownValue(serde_json::Value),
210}
211
212/// Retrieve a list of RQ Queues. Note: Queue names are not URL safe, so not returning a detail view.
213pub async fn core_background_queues_retrieve(
214    configuration: &configuration::Configuration,
215) -> Result<
216    ::std::collections::HashMap<String, serde_json::Value>,
217    Error<CoreBackgroundQueuesRetrieveError>,
218> {
219    let local_var_configuration = configuration;
220
221    let local_var_client = &local_var_configuration.client;
222
223    let local_var_uri_str = format!(
224        "{}/api/core/background-queues/",
225        local_var_configuration.base_path
226    );
227    let mut local_var_req_builder =
228        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
229
230    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
231        local_var_req_builder =
232            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
233    }
234    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
235        let local_var_key = local_var_apikey.key.clone();
236        let local_var_value = match local_var_apikey.prefix {
237            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
238            None => local_var_key,
239        };
240        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
241    };
242
243    let local_var_req = local_var_req_builder.build()?;
244    let local_var_resp = local_var_client.execute(local_var_req).await?;
245
246    let local_var_status = local_var_resp.status();
247    let local_var_content = local_var_resp.text().await?;
248
249    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
250        serde_json::from_str(&local_var_content).map_err(Error::from)
251    } else {
252        let local_var_entity: Option<CoreBackgroundQueuesRetrieveError> =
253            serde_json::from_str(&local_var_content).ok();
254        let local_var_error = ResponseContent {
255            status: local_var_status,
256            content: local_var_content,
257            entity: local_var_entity,
258        };
259        Err(Error::ResponseError(local_var_error))
260    }
261}
262
263/// Retrieve a list of RQ Queues. Note: Queue names are not URL safe, so not returning a detail view.
264pub async fn core_background_queues_retrieve_by_name(
265    configuration: &configuration::Configuration,
266    name: &str,
267) -> Result<
268    ::std::collections::HashMap<String, serde_json::Value>,
269    Error<CoreBackgroundQueuesRetrieveByNameError>,
270> {
271    let local_var_configuration = configuration;
272
273    let local_var_client = &local_var_configuration.client;
274
275    let local_var_uri_str = format!(
276        "{}/api/core/background-queues/{name}/",
277        local_var_configuration.base_path,
278        name = crate::apis::urlencode(name)
279    );
280    let mut local_var_req_builder =
281        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
282
283    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
284        local_var_req_builder =
285            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
286    }
287    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
288        let local_var_key = local_var_apikey.key.clone();
289        let local_var_value = match local_var_apikey.prefix {
290            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
291            None => local_var_key,
292        };
293        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
294    };
295
296    let local_var_req = local_var_req_builder.build()?;
297    let local_var_resp = local_var_client.execute(local_var_req).await?;
298
299    let local_var_status = local_var_resp.status();
300    let local_var_content = local_var_resp.text().await?;
301
302    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
303        serde_json::from_str(&local_var_content).map_err(Error::from)
304    } else {
305        let local_var_entity: Option<CoreBackgroundQueuesRetrieveByNameError> =
306            serde_json::from_str(&local_var_content).ok();
307        let local_var_error = ResponseContent {
308            status: local_var_status,
309            content: local_var_content,
310            entity: local_var_entity,
311        };
312        Err(Error::ResponseError(local_var_error))
313    }
314}
315
316/// Retrieve a list of RQ Tasks.
317pub async fn core_background_tasks_delete_create(
318    configuration: &configuration::Configuration,
319    id: &str,
320    background_task_request: crate::models::BackgroundTaskRequest,
321) -> Result<crate::models::BackgroundTask, Error<CoreBackgroundTasksDeleteCreateError>> {
322    let local_var_configuration = configuration;
323
324    let local_var_client = &local_var_configuration.client;
325
326    let local_var_uri_str = format!(
327        "{}/api/core/background-tasks/{id}/delete/",
328        local_var_configuration.base_path,
329        id = crate::apis::urlencode(id)
330    );
331    let mut local_var_req_builder =
332        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
333
334    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
335        local_var_req_builder =
336            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
337    }
338    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
339        let local_var_key = local_var_apikey.key.clone();
340        let local_var_value = match local_var_apikey.prefix {
341            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
342            None => local_var_key,
343        };
344        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
345    };
346    local_var_req_builder = local_var_req_builder.json(&background_task_request);
347
348    let local_var_req = local_var_req_builder.build()?;
349    let local_var_resp = local_var_client.execute(local_var_req).await?;
350
351    let local_var_status = local_var_resp.status();
352    let local_var_content = local_var_resp.text().await?;
353
354    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
355        serde_json::from_str(&local_var_content).map_err(Error::from)
356    } else {
357        let local_var_entity: Option<CoreBackgroundTasksDeleteCreateError> =
358            serde_json::from_str(&local_var_content).ok();
359        let local_var_error = ResponseContent {
360            status: local_var_status,
361            content: local_var_content,
362            entity: local_var_entity,
363        };
364        Err(Error::ResponseError(local_var_error))
365    }
366}
367
368/// Retrieve a list of RQ Tasks.
369pub async fn core_background_tasks_enqueue_create(
370    configuration: &configuration::Configuration,
371    id: &str,
372    background_task_request: crate::models::BackgroundTaskRequest,
373) -> Result<crate::models::BackgroundTask, Error<CoreBackgroundTasksEnqueueCreateError>> {
374    let local_var_configuration = configuration;
375
376    let local_var_client = &local_var_configuration.client;
377
378    let local_var_uri_str = format!(
379        "{}/api/core/background-tasks/{id}/enqueue/",
380        local_var_configuration.base_path,
381        id = crate::apis::urlencode(id)
382    );
383    let mut local_var_req_builder =
384        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
385
386    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
387        local_var_req_builder =
388            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
389    }
390    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
391        let local_var_key = local_var_apikey.key.clone();
392        let local_var_value = match local_var_apikey.prefix {
393            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
394            None => local_var_key,
395        };
396        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
397    };
398    local_var_req_builder = local_var_req_builder.json(&background_task_request);
399
400    let local_var_req = local_var_req_builder.build()?;
401    let local_var_resp = local_var_client.execute(local_var_req).await?;
402
403    let local_var_status = local_var_resp.status();
404    let local_var_content = local_var_resp.text().await?;
405
406    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
407        serde_json::from_str(&local_var_content).map_err(Error::from)
408    } else {
409        let local_var_entity: Option<CoreBackgroundTasksEnqueueCreateError> =
410            serde_json::from_str(&local_var_content).ok();
411        let local_var_error = ResponseContent {
412            status: local_var_status,
413            content: local_var_content,
414            entity: local_var_entity,
415        };
416        Err(Error::ResponseError(local_var_error))
417    }
418}
419
420/// Retrieve a list of RQ Tasks.
421pub async fn core_background_tasks_requeue_create(
422    configuration: &configuration::Configuration,
423    id: &str,
424    background_task_request: crate::models::BackgroundTaskRequest,
425) -> Result<crate::models::BackgroundTask, Error<CoreBackgroundTasksRequeueCreateError>> {
426    let local_var_configuration = configuration;
427
428    let local_var_client = &local_var_configuration.client;
429
430    let local_var_uri_str = format!(
431        "{}/api/core/background-tasks/{id}/requeue/",
432        local_var_configuration.base_path,
433        id = crate::apis::urlencode(id)
434    );
435    let mut local_var_req_builder =
436        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
437
438    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
439        local_var_req_builder =
440            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
441    }
442    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
443        let local_var_key = local_var_apikey.key.clone();
444        let local_var_value = match local_var_apikey.prefix {
445            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
446            None => local_var_key,
447        };
448        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
449    };
450    local_var_req_builder = local_var_req_builder.json(&background_task_request);
451
452    let local_var_req = local_var_req_builder.build()?;
453    let local_var_resp = local_var_client.execute(local_var_req).await?;
454
455    let local_var_status = local_var_resp.status();
456    let local_var_content = local_var_resp.text().await?;
457
458    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
459        serde_json::from_str(&local_var_content).map_err(Error::from)
460    } else {
461        let local_var_entity: Option<CoreBackgroundTasksRequeueCreateError> =
462            serde_json::from_str(&local_var_content).ok();
463        let local_var_error = ResponseContent {
464            status: local_var_status,
465            content: local_var_content,
466            entity: local_var_entity,
467        };
468        Err(Error::ResponseError(local_var_error))
469    }
470}
471
472/// Retrieve a list of RQ Tasks.
473pub async fn core_background_tasks_retrieve(
474    configuration: &configuration::Configuration,
475) -> Result<
476    ::std::collections::HashMap<String, serde_json::Value>,
477    Error<CoreBackgroundTasksRetrieveError>,
478> {
479    let local_var_configuration = configuration;
480
481    let local_var_client = &local_var_configuration.client;
482
483    let local_var_uri_str = format!(
484        "{}/api/core/background-tasks/",
485        local_var_configuration.base_path
486    );
487    let mut local_var_req_builder =
488        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
489
490    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
491        local_var_req_builder =
492            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
493    }
494    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
495        let local_var_key = local_var_apikey.key.clone();
496        let local_var_value = match local_var_apikey.prefix {
497            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
498            None => local_var_key,
499        };
500        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
501    };
502
503    let local_var_req = local_var_req_builder.build()?;
504    let local_var_resp = local_var_client.execute(local_var_req).await?;
505
506    let local_var_status = local_var_resp.status();
507    let local_var_content = local_var_resp.text().await?;
508
509    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
510        serde_json::from_str(&local_var_content).map_err(Error::from)
511    } else {
512        let local_var_entity: Option<CoreBackgroundTasksRetrieveError> =
513            serde_json::from_str(&local_var_content).ok();
514        let local_var_error = ResponseContent {
515            status: local_var_status,
516            content: local_var_content,
517            entity: local_var_entity,
518        };
519        Err(Error::ResponseError(local_var_error))
520    }
521}
522
523/// Retrieve a list of RQ Tasks.
524pub async fn core_background_tasks_retrieve_by_id(
525    configuration: &configuration::Configuration,
526    id: &str,
527) -> Result<
528    ::std::collections::HashMap<String, serde_json::Value>,
529    Error<CoreBackgroundTasksRetrieveByIdError>,
530> {
531    let local_var_configuration = configuration;
532
533    let local_var_client = &local_var_configuration.client;
534
535    let local_var_uri_str = format!(
536        "{}/api/core/background-tasks/{id}/",
537        local_var_configuration.base_path,
538        id = crate::apis::urlencode(id)
539    );
540    let mut local_var_req_builder =
541        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
542
543    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
544        local_var_req_builder =
545            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
546    }
547    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
548        let local_var_key = local_var_apikey.key.clone();
549        let local_var_value = match local_var_apikey.prefix {
550            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
551            None => local_var_key,
552        };
553        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
554    };
555
556    let local_var_req = local_var_req_builder.build()?;
557    let local_var_resp = local_var_client.execute(local_var_req).await?;
558
559    let local_var_status = local_var_resp.status();
560    let local_var_content = local_var_resp.text().await?;
561
562    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
563        serde_json::from_str(&local_var_content).map_err(Error::from)
564    } else {
565        let local_var_entity: Option<CoreBackgroundTasksRetrieveByIdError> =
566            serde_json::from_str(&local_var_content).ok();
567        let local_var_error = ResponseContent {
568            status: local_var_status,
569            content: local_var_content,
570            entity: local_var_entity,
571        };
572        Err(Error::ResponseError(local_var_error))
573    }
574}
575
576/// Retrieve a list of RQ Tasks.
577pub async fn core_background_tasks_stop_create(
578    configuration: &configuration::Configuration,
579    id: &str,
580    background_task_request: crate::models::BackgroundTaskRequest,
581) -> Result<crate::models::BackgroundTask, Error<CoreBackgroundTasksStopCreateError>> {
582    let local_var_configuration = configuration;
583
584    let local_var_client = &local_var_configuration.client;
585
586    let local_var_uri_str = format!(
587        "{}/api/core/background-tasks/{id}/stop/",
588        local_var_configuration.base_path,
589        id = crate::apis::urlencode(id)
590    );
591    let mut local_var_req_builder =
592        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
593
594    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
595        local_var_req_builder =
596            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
597    }
598    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
599        let local_var_key = local_var_apikey.key.clone();
600        let local_var_value = match local_var_apikey.prefix {
601            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
602            None => local_var_key,
603        };
604        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
605    };
606    local_var_req_builder = local_var_req_builder.json(&background_task_request);
607
608    let local_var_req = local_var_req_builder.build()?;
609    let local_var_resp = local_var_client.execute(local_var_req).await?;
610
611    let local_var_status = local_var_resp.status();
612    let local_var_content = local_var_resp.text().await?;
613
614    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
615        serde_json::from_str(&local_var_content).map_err(Error::from)
616    } else {
617        let local_var_entity: Option<CoreBackgroundTasksStopCreateError> =
618            serde_json::from_str(&local_var_content).ok();
619        let local_var_error = ResponseContent {
620            status: local_var_status,
621            content: local_var_content,
622            entity: local_var_entity,
623        };
624        Err(Error::ResponseError(local_var_error))
625    }
626}
627
628/// Retrieve a list of RQ Workers.
629pub async fn core_background_workers_retrieve(
630    configuration: &configuration::Configuration,
631) -> Result<
632    ::std::collections::HashMap<String, serde_json::Value>,
633    Error<CoreBackgroundWorkersRetrieveError>,
634> {
635    let local_var_configuration = configuration;
636
637    let local_var_client = &local_var_configuration.client;
638
639    let local_var_uri_str = format!(
640        "{}/api/core/background-workers/",
641        local_var_configuration.base_path
642    );
643    let mut local_var_req_builder =
644        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
645
646    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
647        local_var_req_builder =
648            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
649    }
650    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
651        let local_var_key = local_var_apikey.key.clone();
652        let local_var_value = match local_var_apikey.prefix {
653            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
654            None => local_var_key,
655        };
656        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
657    };
658
659    let local_var_req = local_var_req_builder.build()?;
660    let local_var_resp = local_var_client.execute(local_var_req).await?;
661
662    let local_var_status = local_var_resp.status();
663    let local_var_content = local_var_resp.text().await?;
664
665    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
666        serde_json::from_str(&local_var_content).map_err(Error::from)
667    } else {
668        let local_var_entity: Option<CoreBackgroundWorkersRetrieveError> =
669            serde_json::from_str(&local_var_content).ok();
670        let local_var_error = ResponseContent {
671            status: local_var_status,
672            content: local_var_content,
673            entity: local_var_entity,
674        };
675        Err(Error::ResponseError(local_var_error))
676    }
677}
678
679/// Retrieve a list of RQ Workers.
680pub async fn core_background_workers_retrieve_by_name(
681    configuration: &configuration::Configuration,
682    name: &str,
683) -> Result<
684    ::std::collections::HashMap<String, serde_json::Value>,
685    Error<CoreBackgroundWorkersRetrieveByNameError>,
686> {
687    let local_var_configuration = configuration;
688
689    let local_var_client = &local_var_configuration.client;
690
691    let local_var_uri_str = format!(
692        "{}/api/core/background-workers/{name}/",
693        local_var_configuration.base_path,
694        name = crate::apis::urlencode(name)
695    );
696    let mut local_var_req_builder =
697        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
698
699    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
700        local_var_req_builder =
701            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
702    }
703    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
704        let local_var_key = local_var_apikey.key.clone();
705        let local_var_value = match local_var_apikey.prefix {
706            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
707            None => local_var_key,
708        };
709        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
710    };
711
712    let local_var_req = local_var_req_builder.build()?;
713    let local_var_resp = local_var_client.execute(local_var_req).await?;
714
715    let local_var_status = local_var_resp.status();
716    let local_var_content = local_var_resp.text().await?;
717
718    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
719        serde_json::from_str(&local_var_content).map_err(Error::from)
720    } else {
721        let local_var_entity: Option<CoreBackgroundWorkersRetrieveByNameError> =
722            serde_json::from_str(&local_var_content).ok();
723        let local_var_error = ResponseContent {
724            status: local_var_status,
725            content: local_var_content,
726            entity: local_var_entity,
727        };
728        Err(Error::ResponseError(local_var_error))
729    }
730}
731
732/// Get a list of data file objects.
733pub async fn core_data_files_list(
734    configuration: &configuration::Configuration,
735    created: Option<Vec<String>>,
736    created__empty: Option<Vec<String>>,
737    created__gt: Option<Vec<String>>,
738    created__gte: Option<Vec<String>>,
739    created__lt: Option<Vec<String>>,
740    created__lte: Option<Vec<String>>,
741    created__n: Option<Vec<String>>,
742    created_by_request: Option<&str>,
743    hash: Option<Vec<String>>,
744    hash__empty: Option<bool>,
745    hash__ic: Option<Vec<String>>,
746    hash__ie: Option<Vec<String>>,
747    hash__iew: Option<Vec<String>>,
748    hash__iregex: Option<Vec<String>>,
749    hash__isw: Option<Vec<String>>,
750    hash__n: Option<Vec<String>>,
751    hash__nic: Option<Vec<String>>,
752    hash__nie: Option<Vec<String>>,
753    hash__niew: Option<Vec<String>>,
754    hash__nisw: Option<Vec<String>>,
755    hash__regex: Option<Vec<String>>,
756    id: Option<Vec<i32>>,
757    id__empty: Option<bool>,
758    id__gt: Option<Vec<i32>>,
759    id__gte: Option<Vec<i32>>,
760    id__lt: Option<Vec<i32>>,
761    id__lte: Option<Vec<i32>>,
762    id__n: Option<Vec<i32>>,
763    last_updated: Option<Vec<String>>,
764    last_updated__empty: Option<Vec<String>>,
765    last_updated__gt: Option<Vec<String>>,
766    last_updated__gte: Option<Vec<String>>,
767    last_updated__lt: Option<Vec<String>>,
768    last_updated__lte: Option<Vec<String>>,
769    last_updated__n: Option<Vec<String>>,
770    limit: Option<i32>,
771    modified_by_request: Option<&str>,
772    offset: Option<i32>,
773    ordering: Option<&str>,
774    path: Option<Vec<String>>,
775    path__empty: Option<bool>,
776    path__ic: Option<Vec<String>>,
777    path__ie: Option<Vec<String>>,
778    path__iew: Option<Vec<String>>,
779    path__iregex: Option<Vec<String>>,
780    path__isw: Option<Vec<String>>,
781    path__n: Option<Vec<String>>,
782    path__nic: Option<Vec<String>>,
783    path__nie: Option<Vec<String>>,
784    path__niew: Option<Vec<String>>,
785    path__nisw: Option<Vec<String>>,
786    path__regex: Option<Vec<String>>,
787    q: Option<&str>,
788    size: Option<Vec<i32>>,
789    size__empty: Option<bool>,
790    size__gt: Option<Vec<i32>>,
791    size__gte: Option<Vec<i32>>,
792    size__lt: Option<Vec<i32>>,
793    size__lte: Option<Vec<i32>>,
794    size__n: Option<Vec<i32>>,
795    source: Option<Vec<String>>,
796    source__n: Option<Vec<String>>,
797    source_id: Option<Vec<i32>>,
798    source_id__n: Option<Vec<i32>>,
799    updated_by_request: Option<&str>,
800) -> Result<crate::models::PaginatedDataFileList, Error<CoreDataFilesListError>> {
801    let local_var_configuration = configuration;
802
803    let local_var_client = &local_var_configuration.client;
804
805    let local_var_uri_str = format!("{}/api/core/data-files/", local_var_configuration.base_path);
806    let mut local_var_req_builder =
807        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
808
809    if let Some(ref local_var_str) = created {
810        local_var_req_builder = match "multi" {
811            "multi" => local_var_req_builder.query(
812                &local_var_str
813                    .into_iter()
814                    .map(|p| ("created".to_owned(), p.to_string()))
815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
816            ),
817            _ => local_var_req_builder.query(&[(
818                "created",
819                &local_var_str
820                    .into_iter()
821                    .map(|p| p.to_string())
822                    .collect::<Vec<String>>()
823                    .join(",")
824                    .to_string(),
825            )]),
826        };
827    }
828    if let Some(ref local_var_str) = created__empty {
829        local_var_req_builder = match "multi" {
830            "multi" => local_var_req_builder.query(
831                &local_var_str
832                    .into_iter()
833                    .map(|p| ("created__empty".to_owned(), p.to_string()))
834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
835            ),
836            _ => local_var_req_builder.query(&[(
837                "created__empty",
838                &local_var_str
839                    .into_iter()
840                    .map(|p| p.to_string())
841                    .collect::<Vec<String>>()
842                    .join(",")
843                    .to_string(),
844            )]),
845        };
846    }
847    if let Some(ref local_var_str) = created__gt {
848        local_var_req_builder = match "multi" {
849            "multi" => local_var_req_builder.query(
850                &local_var_str
851                    .into_iter()
852                    .map(|p| ("created__gt".to_owned(), p.to_string()))
853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
854            ),
855            _ => local_var_req_builder.query(&[(
856                "created__gt",
857                &local_var_str
858                    .into_iter()
859                    .map(|p| p.to_string())
860                    .collect::<Vec<String>>()
861                    .join(",")
862                    .to_string(),
863            )]),
864        };
865    }
866    if let Some(ref local_var_str) = created__gte {
867        local_var_req_builder = match "multi" {
868            "multi" => local_var_req_builder.query(
869                &local_var_str
870                    .into_iter()
871                    .map(|p| ("created__gte".to_owned(), p.to_string()))
872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
873            ),
874            _ => local_var_req_builder.query(&[(
875                "created__gte",
876                &local_var_str
877                    .into_iter()
878                    .map(|p| p.to_string())
879                    .collect::<Vec<String>>()
880                    .join(",")
881                    .to_string(),
882            )]),
883        };
884    }
885    if let Some(ref local_var_str) = created__lt {
886        local_var_req_builder = match "multi" {
887            "multi" => local_var_req_builder.query(
888                &local_var_str
889                    .into_iter()
890                    .map(|p| ("created__lt".to_owned(), p.to_string()))
891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
892            ),
893            _ => local_var_req_builder.query(&[(
894                "created__lt",
895                &local_var_str
896                    .into_iter()
897                    .map(|p| p.to_string())
898                    .collect::<Vec<String>>()
899                    .join(",")
900                    .to_string(),
901            )]),
902        };
903    }
904    if let Some(ref local_var_str) = created__lte {
905        local_var_req_builder = match "multi" {
906            "multi" => local_var_req_builder.query(
907                &local_var_str
908                    .into_iter()
909                    .map(|p| ("created__lte".to_owned(), p.to_string()))
910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
911            ),
912            _ => local_var_req_builder.query(&[(
913                "created__lte",
914                &local_var_str
915                    .into_iter()
916                    .map(|p| p.to_string())
917                    .collect::<Vec<String>>()
918                    .join(",")
919                    .to_string(),
920            )]),
921        };
922    }
923    if let Some(ref local_var_str) = created__n {
924        local_var_req_builder = match "multi" {
925            "multi" => local_var_req_builder.query(
926                &local_var_str
927                    .into_iter()
928                    .map(|p| ("created__n".to_owned(), p.to_string()))
929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
930            ),
931            _ => local_var_req_builder.query(&[(
932                "created__n",
933                &local_var_str
934                    .into_iter()
935                    .map(|p| p.to_string())
936                    .collect::<Vec<String>>()
937                    .join(",")
938                    .to_string(),
939            )]),
940        };
941    }
942    if let Some(ref local_var_str) = created_by_request {
943        local_var_req_builder =
944            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
945    }
946    if let Some(ref local_var_str) = hash {
947        local_var_req_builder = match "multi" {
948            "multi" => local_var_req_builder.query(
949                &local_var_str
950                    .into_iter()
951                    .map(|p| ("hash".to_owned(), p.to_string()))
952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
953            ),
954            _ => local_var_req_builder.query(&[(
955                "hash",
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) = hash__empty {
966        local_var_req_builder =
967            local_var_req_builder.query(&[("hash__empty", &local_var_str.to_string())]);
968    }
969    if let Some(ref local_var_str) = hash__ic {
970        local_var_req_builder = match "multi" {
971            "multi" => local_var_req_builder.query(
972                &local_var_str
973                    .into_iter()
974                    .map(|p| ("hash__ic".to_owned(), p.to_string()))
975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
976            ),
977            _ => local_var_req_builder.query(&[(
978                "hash__ic",
979                &local_var_str
980                    .into_iter()
981                    .map(|p| p.to_string())
982                    .collect::<Vec<String>>()
983                    .join(",")
984                    .to_string(),
985            )]),
986        };
987    }
988    if let Some(ref local_var_str) = hash__ie {
989        local_var_req_builder = match "multi" {
990            "multi" => local_var_req_builder.query(
991                &local_var_str
992                    .into_iter()
993                    .map(|p| ("hash__ie".to_owned(), p.to_string()))
994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
995            ),
996            _ => local_var_req_builder.query(&[(
997                "hash__ie",
998                &local_var_str
999                    .into_iter()
1000                    .map(|p| p.to_string())
1001                    .collect::<Vec<String>>()
1002                    .join(",")
1003                    .to_string(),
1004            )]),
1005        };
1006    }
1007    if let Some(ref local_var_str) = hash__iew {
1008        local_var_req_builder = match "multi" {
1009            "multi" => local_var_req_builder.query(
1010                &local_var_str
1011                    .into_iter()
1012                    .map(|p| ("hash__iew".to_owned(), p.to_string()))
1013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1014            ),
1015            _ => local_var_req_builder.query(&[(
1016                "hash__iew",
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) = hash__iregex {
1027        local_var_req_builder = match "multi" {
1028            "multi" => local_var_req_builder.query(
1029                &local_var_str
1030                    .into_iter()
1031                    .map(|p| ("hash__iregex".to_owned(), p.to_string()))
1032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1033            ),
1034            _ => local_var_req_builder.query(&[(
1035                "hash__iregex",
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) = hash__isw {
1046        local_var_req_builder = match "multi" {
1047            "multi" => local_var_req_builder.query(
1048                &local_var_str
1049                    .into_iter()
1050                    .map(|p| ("hash__isw".to_owned(), p.to_string()))
1051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1052            ),
1053            _ => local_var_req_builder.query(&[(
1054                "hash__isw",
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) = hash__n {
1065        local_var_req_builder = match "multi" {
1066            "multi" => local_var_req_builder.query(
1067                &local_var_str
1068                    .into_iter()
1069                    .map(|p| ("hash__n".to_owned(), p.to_string()))
1070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1071            ),
1072            _ => local_var_req_builder.query(&[(
1073                "hash__n",
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) = hash__nic {
1084        local_var_req_builder = match "multi" {
1085            "multi" => local_var_req_builder.query(
1086                &local_var_str
1087                    .into_iter()
1088                    .map(|p| ("hash__nic".to_owned(), p.to_string()))
1089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1090            ),
1091            _ => local_var_req_builder.query(&[(
1092                "hash__nic",
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) = hash__nie {
1103        local_var_req_builder = match "multi" {
1104            "multi" => local_var_req_builder.query(
1105                &local_var_str
1106                    .into_iter()
1107                    .map(|p| ("hash__nie".to_owned(), p.to_string()))
1108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1109            ),
1110            _ => local_var_req_builder.query(&[(
1111                "hash__nie",
1112                &local_var_str
1113                    .into_iter()
1114                    .map(|p| p.to_string())
1115                    .collect::<Vec<String>>()
1116                    .join(",")
1117                    .to_string(),
1118            )]),
1119        };
1120    }
1121    if let Some(ref local_var_str) = hash__niew {
1122        local_var_req_builder = match "multi" {
1123            "multi" => local_var_req_builder.query(
1124                &local_var_str
1125                    .into_iter()
1126                    .map(|p| ("hash__niew".to_owned(), p.to_string()))
1127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1128            ),
1129            _ => local_var_req_builder.query(&[(
1130                "hash__niew",
1131                &local_var_str
1132                    .into_iter()
1133                    .map(|p| p.to_string())
1134                    .collect::<Vec<String>>()
1135                    .join(",")
1136                    .to_string(),
1137            )]),
1138        };
1139    }
1140    if let Some(ref local_var_str) = hash__nisw {
1141        local_var_req_builder = match "multi" {
1142            "multi" => local_var_req_builder.query(
1143                &local_var_str
1144                    .into_iter()
1145                    .map(|p| ("hash__nisw".to_owned(), p.to_string()))
1146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1147            ),
1148            _ => local_var_req_builder.query(&[(
1149                "hash__nisw",
1150                &local_var_str
1151                    .into_iter()
1152                    .map(|p| p.to_string())
1153                    .collect::<Vec<String>>()
1154                    .join(",")
1155                    .to_string(),
1156            )]),
1157        };
1158    }
1159    if let Some(ref local_var_str) = hash__regex {
1160        local_var_req_builder = match "multi" {
1161            "multi" => local_var_req_builder.query(
1162                &local_var_str
1163                    .into_iter()
1164                    .map(|p| ("hash__regex".to_owned(), p.to_string()))
1165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1166            ),
1167            _ => local_var_req_builder.query(&[(
1168                "hash__regex",
1169                &local_var_str
1170                    .into_iter()
1171                    .map(|p| p.to_string())
1172                    .collect::<Vec<String>>()
1173                    .join(",")
1174                    .to_string(),
1175            )]),
1176        };
1177    }
1178    if let Some(ref local_var_str) = id {
1179        local_var_req_builder = match "multi" {
1180            "multi" => local_var_req_builder.query(
1181                &local_var_str
1182                    .into_iter()
1183                    .map(|p| ("id".to_owned(), p.to_string()))
1184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1185            ),
1186            _ => local_var_req_builder.query(&[(
1187                "id",
1188                &local_var_str
1189                    .into_iter()
1190                    .map(|p| p.to_string())
1191                    .collect::<Vec<String>>()
1192                    .join(",")
1193                    .to_string(),
1194            )]),
1195        };
1196    }
1197    if let Some(ref local_var_str) = id__empty {
1198        local_var_req_builder =
1199            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1200    }
1201    if let Some(ref local_var_str) = id__gt {
1202        local_var_req_builder = match "multi" {
1203            "multi" => local_var_req_builder.query(
1204                &local_var_str
1205                    .into_iter()
1206                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1208            ),
1209            _ => local_var_req_builder.query(&[(
1210                "id__gt",
1211                &local_var_str
1212                    .into_iter()
1213                    .map(|p| p.to_string())
1214                    .collect::<Vec<String>>()
1215                    .join(",")
1216                    .to_string(),
1217            )]),
1218        };
1219    }
1220    if let Some(ref local_var_str) = id__gte {
1221        local_var_req_builder = match "multi" {
1222            "multi" => local_var_req_builder.query(
1223                &local_var_str
1224                    .into_iter()
1225                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1227            ),
1228            _ => local_var_req_builder.query(&[(
1229                "id__gte",
1230                &local_var_str
1231                    .into_iter()
1232                    .map(|p| p.to_string())
1233                    .collect::<Vec<String>>()
1234                    .join(",")
1235                    .to_string(),
1236            )]),
1237        };
1238    }
1239    if let Some(ref local_var_str) = id__lt {
1240        local_var_req_builder = match "multi" {
1241            "multi" => local_var_req_builder.query(
1242                &local_var_str
1243                    .into_iter()
1244                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1246            ),
1247            _ => local_var_req_builder.query(&[(
1248                "id__lt",
1249                &local_var_str
1250                    .into_iter()
1251                    .map(|p| p.to_string())
1252                    .collect::<Vec<String>>()
1253                    .join(",")
1254                    .to_string(),
1255            )]),
1256        };
1257    }
1258    if let Some(ref local_var_str) = id__lte {
1259        local_var_req_builder = match "multi" {
1260            "multi" => local_var_req_builder.query(
1261                &local_var_str
1262                    .into_iter()
1263                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1265            ),
1266            _ => local_var_req_builder.query(&[(
1267                "id__lte",
1268                &local_var_str
1269                    .into_iter()
1270                    .map(|p| p.to_string())
1271                    .collect::<Vec<String>>()
1272                    .join(",")
1273                    .to_string(),
1274            )]),
1275        };
1276    }
1277    if let Some(ref local_var_str) = id__n {
1278        local_var_req_builder = match "multi" {
1279            "multi" => local_var_req_builder.query(
1280                &local_var_str
1281                    .into_iter()
1282                    .map(|p| ("id__n".to_owned(), p.to_string()))
1283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1284            ),
1285            _ => local_var_req_builder.query(&[(
1286                "id__n",
1287                &local_var_str
1288                    .into_iter()
1289                    .map(|p| p.to_string())
1290                    .collect::<Vec<String>>()
1291                    .join(",")
1292                    .to_string(),
1293            )]),
1294        };
1295    }
1296    if let Some(ref local_var_str) = last_updated {
1297        local_var_req_builder = match "multi" {
1298            "multi" => local_var_req_builder.query(
1299                &local_var_str
1300                    .into_iter()
1301                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1303            ),
1304            _ => local_var_req_builder.query(&[(
1305                "last_updated",
1306                &local_var_str
1307                    .into_iter()
1308                    .map(|p| p.to_string())
1309                    .collect::<Vec<String>>()
1310                    .join(",")
1311                    .to_string(),
1312            )]),
1313        };
1314    }
1315    if let Some(ref local_var_str) = last_updated__empty {
1316        local_var_req_builder = match "multi" {
1317            "multi" => local_var_req_builder.query(
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1322            ),
1323            _ => local_var_req_builder.query(&[(
1324                "last_updated__empty",
1325                &local_var_str
1326                    .into_iter()
1327                    .map(|p| p.to_string())
1328                    .collect::<Vec<String>>()
1329                    .join(",")
1330                    .to_string(),
1331            )]),
1332        };
1333    }
1334    if let Some(ref local_var_str) = last_updated__gt {
1335        local_var_req_builder = match "multi" {
1336            "multi" => local_var_req_builder.query(
1337                &local_var_str
1338                    .into_iter()
1339                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1341            ),
1342            _ => local_var_req_builder.query(&[(
1343                "last_updated__gt",
1344                &local_var_str
1345                    .into_iter()
1346                    .map(|p| p.to_string())
1347                    .collect::<Vec<String>>()
1348                    .join(",")
1349                    .to_string(),
1350            )]),
1351        };
1352    }
1353    if let Some(ref local_var_str) = last_updated__gte {
1354        local_var_req_builder = match "multi" {
1355            "multi" => local_var_req_builder.query(
1356                &local_var_str
1357                    .into_iter()
1358                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1360            ),
1361            _ => local_var_req_builder.query(&[(
1362                "last_updated__gte",
1363                &local_var_str
1364                    .into_iter()
1365                    .map(|p| p.to_string())
1366                    .collect::<Vec<String>>()
1367                    .join(",")
1368                    .to_string(),
1369            )]),
1370        };
1371    }
1372    if let Some(ref local_var_str) = last_updated__lt {
1373        local_var_req_builder = match "multi" {
1374            "multi" => local_var_req_builder.query(
1375                &local_var_str
1376                    .into_iter()
1377                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1379            ),
1380            _ => local_var_req_builder.query(&[(
1381                "last_updated__lt",
1382                &local_var_str
1383                    .into_iter()
1384                    .map(|p| p.to_string())
1385                    .collect::<Vec<String>>()
1386                    .join(",")
1387                    .to_string(),
1388            )]),
1389        };
1390    }
1391    if let Some(ref local_var_str) = last_updated__lte {
1392        local_var_req_builder = match "multi" {
1393            "multi" => local_var_req_builder.query(
1394                &local_var_str
1395                    .into_iter()
1396                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1398            ),
1399            _ => local_var_req_builder.query(&[(
1400                "last_updated__lte",
1401                &local_var_str
1402                    .into_iter()
1403                    .map(|p| p.to_string())
1404                    .collect::<Vec<String>>()
1405                    .join(",")
1406                    .to_string(),
1407            )]),
1408        };
1409    }
1410    if let Some(ref local_var_str) = last_updated__n {
1411        local_var_req_builder = match "multi" {
1412            "multi" => local_var_req_builder.query(
1413                &local_var_str
1414                    .into_iter()
1415                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1417            ),
1418            _ => local_var_req_builder.query(&[(
1419                "last_updated__n",
1420                &local_var_str
1421                    .into_iter()
1422                    .map(|p| p.to_string())
1423                    .collect::<Vec<String>>()
1424                    .join(",")
1425                    .to_string(),
1426            )]),
1427        };
1428    }
1429    if let Some(ref local_var_str) = limit {
1430        local_var_req_builder =
1431            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1432    }
1433    if let Some(ref local_var_str) = modified_by_request {
1434        local_var_req_builder =
1435            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1436    }
1437    if let Some(ref local_var_str) = offset {
1438        local_var_req_builder =
1439            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1440    }
1441    if let Some(ref local_var_str) = ordering {
1442        local_var_req_builder =
1443            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1444    }
1445    if let Some(ref local_var_str) = path {
1446        local_var_req_builder = match "multi" {
1447            "multi" => local_var_req_builder.query(
1448                &local_var_str
1449                    .into_iter()
1450                    .map(|p| ("path".to_owned(), p.to_string()))
1451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1452            ),
1453            _ => local_var_req_builder.query(&[(
1454                "path",
1455                &local_var_str
1456                    .into_iter()
1457                    .map(|p| p.to_string())
1458                    .collect::<Vec<String>>()
1459                    .join(",")
1460                    .to_string(),
1461            )]),
1462        };
1463    }
1464    if let Some(ref local_var_str) = path__empty {
1465        local_var_req_builder =
1466            local_var_req_builder.query(&[("path__empty", &local_var_str.to_string())]);
1467    }
1468    if let Some(ref local_var_str) = path__ic {
1469        local_var_req_builder = match "multi" {
1470            "multi" => local_var_req_builder.query(
1471                &local_var_str
1472                    .into_iter()
1473                    .map(|p| ("path__ic".to_owned(), p.to_string()))
1474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1475            ),
1476            _ => local_var_req_builder.query(&[(
1477                "path__ic",
1478                &local_var_str
1479                    .into_iter()
1480                    .map(|p| p.to_string())
1481                    .collect::<Vec<String>>()
1482                    .join(",")
1483                    .to_string(),
1484            )]),
1485        };
1486    }
1487    if let Some(ref local_var_str) = path__ie {
1488        local_var_req_builder = match "multi" {
1489            "multi" => local_var_req_builder.query(
1490                &local_var_str
1491                    .into_iter()
1492                    .map(|p| ("path__ie".to_owned(), p.to_string()))
1493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1494            ),
1495            _ => local_var_req_builder.query(&[(
1496                "path__ie",
1497                &local_var_str
1498                    .into_iter()
1499                    .map(|p| p.to_string())
1500                    .collect::<Vec<String>>()
1501                    .join(",")
1502                    .to_string(),
1503            )]),
1504        };
1505    }
1506    if let Some(ref local_var_str) = path__iew {
1507        local_var_req_builder = match "multi" {
1508            "multi" => local_var_req_builder.query(
1509                &local_var_str
1510                    .into_iter()
1511                    .map(|p| ("path__iew".to_owned(), p.to_string()))
1512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1513            ),
1514            _ => local_var_req_builder.query(&[(
1515                "path__iew",
1516                &local_var_str
1517                    .into_iter()
1518                    .map(|p| p.to_string())
1519                    .collect::<Vec<String>>()
1520                    .join(",")
1521                    .to_string(),
1522            )]),
1523        };
1524    }
1525    if let Some(ref local_var_str) = path__iregex {
1526        local_var_req_builder = match "multi" {
1527            "multi" => local_var_req_builder.query(
1528                &local_var_str
1529                    .into_iter()
1530                    .map(|p| ("path__iregex".to_owned(), p.to_string()))
1531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1532            ),
1533            _ => local_var_req_builder.query(&[(
1534                "path__iregex",
1535                &local_var_str
1536                    .into_iter()
1537                    .map(|p| p.to_string())
1538                    .collect::<Vec<String>>()
1539                    .join(",")
1540                    .to_string(),
1541            )]),
1542        };
1543    }
1544    if let Some(ref local_var_str) = path__isw {
1545        local_var_req_builder = match "multi" {
1546            "multi" => local_var_req_builder.query(
1547                &local_var_str
1548                    .into_iter()
1549                    .map(|p| ("path__isw".to_owned(), p.to_string()))
1550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1551            ),
1552            _ => local_var_req_builder.query(&[(
1553                "path__isw",
1554                &local_var_str
1555                    .into_iter()
1556                    .map(|p| p.to_string())
1557                    .collect::<Vec<String>>()
1558                    .join(",")
1559                    .to_string(),
1560            )]),
1561        };
1562    }
1563    if let Some(ref local_var_str) = path__n {
1564        local_var_req_builder = match "multi" {
1565            "multi" => local_var_req_builder.query(
1566                &local_var_str
1567                    .into_iter()
1568                    .map(|p| ("path__n".to_owned(), p.to_string()))
1569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1570            ),
1571            _ => local_var_req_builder.query(&[(
1572                "path__n",
1573                &local_var_str
1574                    .into_iter()
1575                    .map(|p| p.to_string())
1576                    .collect::<Vec<String>>()
1577                    .join(",")
1578                    .to_string(),
1579            )]),
1580        };
1581    }
1582    if let Some(ref local_var_str) = path__nic {
1583        local_var_req_builder = match "multi" {
1584            "multi" => local_var_req_builder.query(
1585                &local_var_str
1586                    .into_iter()
1587                    .map(|p| ("path__nic".to_owned(), p.to_string()))
1588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1589            ),
1590            _ => local_var_req_builder.query(&[(
1591                "path__nic",
1592                &local_var_str
1593                    .into_iter()
1594                    .map(|p| p.to_string())
1595                    .collect::<Vec<String>>()
1596                    .join(",")
1597                    .to_string(),
1598            )]),
1599        };
1600    }
1601    if let Some(ref local_var_str) = path__nie {
1602        local_var_req_builder = match "multi" {
1603            "multi" => local_var_req_builder.query(
1604                &local_var_str
1605                    .into_iter()
1606                    .map(|p| ("path__nie".to_owned(), p.to_string()))
1607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1608            ),
1609            _ => local_var_req_builder.query(&[(
1610                "path__nie",
1611                &local_var_str
1612                    .into_iter()
1613                    .map(|p| p.to_string())
1614                    .collect::<Vec<String>>()
1615                    .join(",")
1616                    .to_string(),
1617            )]),
1618        };
1619    }
1620    if let Some(ref local_var_str) = path__niew {
1621        local_var_req_builder = match "multi" {
1622            "multi" => local_var_req_builder.query(
1623                &local_var_str
1624                    .into_iter()
1625                    .map(|p| ("path__niew".to_owned(), p.to_string()))
1626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1627            ),
1628            _ => local_var_req_builder.query(&[(
1629                "path__niew",
1630                &local_var_str
1631                    .into_iter()
1632                    .map(|p| p.to_string())
1633                    .collect::<Vec<String>>()
1634                    .join(",")
1635                    .to_string(),
1636            )]),
1637        };
1638    }
1639    if let Some(ref local_var_str) = path__nisw {
1640        local_var_req_builder = match "multi" {
1641            "multi" => local_var_req_builder.query(
1642                &local_var_str
1643                    .into_iter()
1644                    .map(|p| ("path__nisw".to_owned(), p.to_string()))
1645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1646            ),
1647            _ => local_var_req_builder.query(&[(
1648                "path__nisw",
1649                &local_var_str
1650                    .into_iter()
1651                    .map(|p| p.to_string())
1652                    .collect::<Vec<String>>()
1653                    .join(",")
1654                    .to_string(),
1655            )]),
1656        };
1657    }
1658    if let Some(ref local_var_str) = path__regex {
1659        local_var_req_builder = match "multi" {
1660            "multi" => local_var_req_builder.query(
1661                &local_var_str
1662                    .into_iter()
1663                    .map(|p| ("path__regex".to_owned(), p.to_string()))
1664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1665            ),
1666            _ => local_var_req_builder.query(&[(
1667                "path__regex",
1668                &local_var_str
1669                    .into_iter()
1670                    .map(|p| p.to_string())
1671                    .collect::<Vec<String>>()
1672                    .join(",")
1673                    .to_string(),
1674            )]),
1675        };
1676    }
1677    if let Some(ref local_var_str) = q {
1678        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1679    }
1680    if let Some(ref local_var_str) = size {
1681        local_var_req_builder = match "multi" {
1682            "multi" => local_var_req_builder.query(
1683                &local_var_str
1684                    .into_iter()
1685                    .map(|p| ("size".to_owned(), p.to_string()))
1686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1687            ),
1688            _ => local_var_req_builder.query(&[(
1689                "size",
1690                &local_var_str
1691                    .into_iter()
1692                    .map(|p| p.to_string())
1693                    .collect::<Vec<String>>()
1694                    .join(",")
1695                    .to_string(),
1696            )]),
1697        };
1698    }
1699    if let Some(ref local_var_str) = size__empty {
1700        local_var_req_builder =
1701            local_var_req_builder.query(&[("size__empty", &local_var_str.to_string())]);
1702    }
1703    if let Some(ref local_var_str) = size__gt {
1704        local_var_req_builder = match "multi" {
1705            "multi" => local_var_req_builder.query(
1706                &local_var_str
1707                    .into_iter()
1708                    .map(|p| ("size__gt".to_owned(), p.to_string()))
1709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1710            ),
1711            _ => local_var_req_builder.query(&[(
1712                "size__gt",
1713                &local_var_str
1714                    .into_iter()
1715                    .map(|p| p.to_string())
1716                    .collect::<Vec<String>>()
1717                    .join(",")
1718                    .to_string(),
1719            )]),
1720        };
1721    }
1722    if let Some(ref local_var_str) = size__gte {
1723        local_var_req_builder = match "multi" {
1724            "multi" => local_var_req_builder.query(
1725                &local_var_str
1726                    .into_iter()
1727                    .map(|p| ("size__gte".to_owned(), p.to_string()))
1728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1729            ),
1730            _ => local_var_req_builder.query(&[(
1731                "size__gte",
1732                &local_var_str
1733                    .into_iter()
1734                    .map(|p| p.to_string())
1735                    .collect::<Vec<String>>()
1736                    .join(",")
1737                    .to_string(),
1738            )]),
1739        };
1740    }
1741    if let Some(ref local_var_str) = size__lt {
1742        local_var_req_builder = match "multi" {
1743            "multi" => local_var_req_builder.query(
1744                &local_var_str
1745                    .into_iter()
1746                    .map(|p| ("size__lt".to_owned(), p.to_string()))
1747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1748            ),
1749            _ => local_var_req_builder.query(&[(
1750                "size__lt",
1751                &local_var_str
1752                    .into_iter()
1753                    .map(|p| p.to_string())
1754                    .collect::<Vec<String>>()
1755                    .join(",")
1756                    .to_string(),
1757            )]),
1758        };
1759    }
1760    if let Some(ref local_var_str) = size__lte {
1761        local_var_req_builder = match "multi" {
1762            "multi" => local_var_req_builder.query(
1763                &local_var_str
1764                    .into_iter()
1765                    .map(|p| ("size__lte".to_owned(), p.to_string()))
1766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1767            ),
1768            _ => local_var_req_builder.query(&[(
1769                "size__lte",
1770                &local_var_str
1771                    .into_iter()
1772                    .map(|p| p.to_string())
1773                    .collect::<Vec<String>>()
1774                    .join(",")
1775                    .to_string(),
1776            )]),
1777        };
1778    }
1779    if let Some(ref local_var_str) = size__n {
1780        local_var_req_builder = match "multi" {
1781            "multi" => local_var_req_builder.query(
1782                &local_var_str
1783                    .into_iter()
1784                    .map(|p| ("size__n".to_owned(), p.to_string()))
1785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1786            ),
1787            _ => local_var_req_builder.query(&[(
1788                "size__n",
1789                &local_var_str
1790                    .into_iter()
1791                    .map(|p| p.to_string())
1792                    .collect::<Vec<String>>()
1793                    .join(",")
1794                    .to_string(),
1795            )]),
1796        };
1797    }
1798    if let Some(ref local_var_str) = source {
1799        local_var_req_builder = match "multi" {
1800            "multi" => local_var_req_builder.query(
1801                &local_var_str
1802                    .into_iter()
1803                    .map(|p| ("source".to_owned(), p.to_string()))
1804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1805            ),
1806            _ => local_var_req_builder.query(&[(
1807                "source",
1808                &local_var_str
1809                    .into_iter()
1810                    .map(|p| p.to_string())
1811                    .collect::<Vec<String>>()
1812                    .join(",")
1813                    .to_string(),
1814            )]),
1815        };
1816    }
1817    if let Some(ref local_var_str) = source__n {
1818        local_var_req_builder = match "multi" {
1819            "multi" => local_var_req_builder.query(
1820                &local_var_str
1821                    .into_iter()
1822                    .map(|p| ("source__n".to_owned(), p.to_string()))
1823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1824            ),
1825            _ => local_var_req_builder.query(&[(
1826                "source__n",
1827                &local_var_str
1828                    .into_iter()
1829                    .map(|p| p.to_string())
1830                    .collect::<Vec<String>>()
1831                    .join(",")
1832                    .to_string(),
1833            )]),
1834        };
1835    }
1836    if let Some(ref local_var_str) = source_id {
1837        local_var_req_builder = match "multi" {
1838            "multi" => local_var_req_builder.query(
1839                &local_var_str
1840                    .into_iter()
1841                    .map(|p| ("source_id".to_owned(), p.to_string()))
1842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1843            ),
1844            _ => local_var_req_builder.query(&[(
1845                "source_id",
1846                &local_var_str
1847                    .into_iter()
1848                    .map(|p| p.to_string())
1849                    .collect::<Vec<String>>()
1850                    .join(",")
1851                    .to_string(),
1852            )]),
1853        };
1854    }
1855    if let Some(ref local_var_str) = source_id__n {
1856        local_var_req_builder = match "multi" {
1857            "multi" => local_var_req_builder.query(
1858                &local_var_str
1859                    .into_iter()
1860                    .map(|p| ("source_id__n".to_owned(), p.to_string()))
1861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1862            ),
1863            _ => local_var_req_builder.query(&[(
1864                "source_id__n",
1865                &local_var_str
1866                    .into_iter()
1867                    .map(|p| p.to_string())
1868                    .collect::<Vec<String>>()
1869                    .join(",")
1870                    .to_string(),
1871            )]),
1872        };
1873    }
1874    if let Some(ref local_var_str) = updated_by_request {
1875        local_var_req_builder =
1876            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
1877    }
1878    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1879        local_var_req_builder =
1880            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1881    }
1882    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1883        let local_var_key = local_var_apikey.key.clone();
1884        let local_var_value = match local_var_apikey.prefix {
1885            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1886            None => local_var_key,
1887        };
1888        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1889    };
1890
1891    let local_var_req = local_var_req_builder.build()?;
1892    let local_var_resp = local_var_client.execute(local_var_req).await?;
1893
1894    let local_var_status = local_var_resp.status();
1895    let local_var_content = local_var_resp.text().await?;
1896
1897    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1898        serde_json::from_str(&local_var_content).map_err(Error::from)
1899    } else {
1900        let local_var_entity: Option<CoreDataFilesListError> =
1901            serde_json::from_str(&local_var_content).ok();
1902        let local_var_error = ResponseContent {
1903            status: local_var_status,
1904            content: local_var_content,
1905            entity: local_var_entity,
1906        };
1907        Err(Error::ResponseError(local_var_error))
1908    }
1909}
1910
1911/// Get a data file object.
1912pub async fn core_data_files_retrieve(
1913    configuration: &configuration::Configuration,
1914    id: i32,
1915) -> Result<crate::models::DataFile, Error<CoreDataFilesRetrieveError>> {
1916    let local_var_configuration = configuration;
1917
1918    let local_var_client = &local_var_configuration.client;
1919
1920    let local_var_uri_str = format!(
1921        "{}/api/core/data-files/{id}/",
1922        local_var_configuration.base_path,
1923        id = id
1924    );
1925    let mut local_var_req_builder =
1926        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1927
1928    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1929        local_var_req_builder =
1930            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1931    }
1932    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1933        let local_var_key = local_var_apikey.key.clone();
1934        let local_var_value = match local_var_apikey.prefix {
1935            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1936            None => local_var_key,
1937        };
1938        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1939    };
1940
1941    let local_var_req = local_var_req_builder.build()?;
1942    let local_var_resp = local_var_client.execute(local_var_req).await?;
1943
1944    let local_var_status = local_var_resp.status();
1945    let local_var_content = local_var_resp.text().await?;
1946
1947    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1948        serde_json::from_str(&local_var_content).map_err(Error::from)
1949    } else {
1950        let local_var_entity: Option<CoreDataFilesRetrieveError> =
1951            serde_json::from_str(&local_var_content).ok();
1952        let local_var_error = ResponseContent {
1953            status: local_var_status,
1954            content: local_var_content,
1955            entity: local_var_entity,
1956        };
1957        Err(Error::ResponseError(local_var_error))
1958    }
1959}
1960
1961/// Delete a list of data source objects.
1962pub async fn core_data_sources_bulk_destroy(
1963    configuration: &configuration::Configuration,
1964    data_source_request: Vec<crate::models::DataSourceRequest>,
1965) -> Result<(), Error<CoreDataSourcesBulkDestroyError>> {
1966    let local_var_configuration = configuration;
1967
1968    let local_var_client = &local_var_configuration.client;
1969
1970    let local_var_uri_str = format!(
1971        "{}/api/core/data-sources/",
1972        local_var_configuration.base_path
1973    );
1974    let mut local_var_req_builder =
1975        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1976
1977    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1978        local_var_req_builder =
1979            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1980    }
1981    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1982        let local_var_key = local_var_apikey.key.clone();
1983        let local_var_value = match local_var_apikey.prefix {
1984            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1985            None => local_var_key,
1986        };
1987        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1988    };
1989    local_var_req_builder = local_var_req_builder.json(&data_source_request);
1990
1991    let local_var_req = local_var_req_builder.build()?;
1992    let local_var_resp = local_var_client.execute(local_var_req).await?;
1993
1994    let local_var_status = local_var_resp.status();
1995    let local_var_content = local_var_resp.text().await?;
1996
1997    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1998        Ok(())
1999    } else {
2000        let local_var_entity: Option<CoreDataSourcesBulkDestroyError> =
2001            serde_json::from_str(&local_var_content).ok();
2002        let local_var_error = ResponseContent {
2003            status: local_var_status,
2004            content: local_var_content,
2005            entity: local_var_entity,
2006        };
2007        Err(Error::ResponseError(local_var_error))
2008    }
2009}
2010
2011/// Patch a list of data source objects.
2012pub async fn core_data_sources_bulk_partial_update(
2013    configuration: &configuration::Configuration,
2014    data_source_request: Vec<crate::models::DataSourceRequest>,
2015) -> Result<Vec<crate::models::DataSource>, Error<CoreDataSourcesBulkPartialUpdateError>> {
2016    let local_var_configuration = configuration;
2017
2018    let local_var_client = &local_var_configuration.client;
2019
2020    let local_var_uri_str = format!(
2021        "{}/api/core/data-sources/",
2022        local_var_configuration.base_path
2023    );
2024    let mut local_var_req_builder =
2025        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2026
2027    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2028        local_var_req_builder =
2029            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2030    }
2031    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2032        let local_var_key = local_var_apikey.key.clone();
2033        let local_var_value = match local_var_apikey.prefix {
2034            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2035            None => local_var_key,
2036        };
2037        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2038    };
2039    local_var_req_builder = local_var_req_builder.json(&data_source_request);
2040
2041    let local_var_req = local_var_req_builder.build()?;
2042    let local_var_resp = local_var_client.execute(local_var_req).await?;
2043
2044    let local_var_status = local_var_resp.status();
2045    let local_var_content = local_var_resp.text().await?;
2046
2047    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2048        serde_json::from_str(&local_var_content).map_err(Error::from)
2049    } else {
2050        let local_var_entity: Option<CoreDataSourcesBulkPartialUpdateError> =
2051            serde_json::from_str(&local_var_content).ok();
2052        let local_var_error = ResponseContent {
2053            status: local_var_status,
2054            content: local_var_content,
2055            entity: local_var_entity,
2056        };
2057        Err(Error::ResponseError(local_var_error))
2058    }
2059}
2060
2061/// Put a list of data source objects.
2062pub async fn core_data_sources_bulk_update(
2063    configuration: &configuration::Configuration,
2064    data_source_request: Vec<crate::models::DataSourceRequest>,
2065) -> Result<Vec<crate::models::DataSource>, Error<CoreDataSourcesBulkUpdateError>> {
2066    let local_var_configuration = configuration;
2067
2068    let local_var_client = &local_var_configuration.client;
2069
2070    let local_var_uri_str = format!(
2071        "{}/api/core/data-sources/",
2072        local_var_configuration.base_path
2073    );
2074    let mut local_var_req_builder =
2075        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2076
2077    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2078        local_var_req_builder =
2079            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2080    }
2081    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2082        let local_var_key = local_var_apikey.key.clone();
2083        let local_var_value = match local_var_apikey.prefix {
2084            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2085            None => local_var_key,
2086        };
2087        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2088    };
2089    local_var_req_builder = local_var_req_builder.json(&data_source_request);
2090
2091    let local_var_req = local_var_req_builder.build()?;
2092    let local_var_resp = local_var_client.execute(local_var_req).await?;
2093
2094    let local_var_status = local_var_resp.status();
2095    let local_var_content = local_var_resp.text().await?;
2096
2097    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2098        serde_json::from_str(&local_var_content).map_err(Error::from)
2099    } else {
2100        let local_var_entity: Option<CoreDataSourcesBulkUpdateError> =
2101            serde_json::from_str(&local_var_content).ok();
2102        let local_var_error = ResponseContent {
2103            status: local_var_status,
2104            content: local_var_content,
2105            entity: local_var_entity,
2106        };
2107        Err(Error::ResponseError(local_var_error))
2108    }
2109}
2110
2111/// Post a list of data source objects.
2112pub async fn core_data_sources_create(
2113    configuration: &configuration::Configuration,
2114    core_data_sources_create_request: crate::models::CoreDataSourcesCreateRequest,
2115) -> Result<crate::models::DataSource, Error<CoreDataSourcesCreateError>> {
2116    let local_var_configuration = configuration;
2117
2118    let local_var_client = &local_var_configuration.client;
2119
2120    let local_var_uri_str = format!(
2121        "{}/api/core/data-sources/",
2122        local_var_configuration.base_path
2123    );
2124    let mut local_var_req_builder =
2125        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2126
2127    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2128        local_var_req_builder =
2129            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2130    }
2131    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2132        let local_var_key = local_var_apikey.key.clone();
2133        let local_var_value = match local_var_apikey.prefix {
2134            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2135            None => local_var_key,
2136        };
2137        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2138    };
2139    local_var_req_builder = local_var_req_builder.json(&core_data_sources_create_request);
2140
2141    let local_var_req = local_var_req_builder.build()?;
2142    let local_var_resp = local_var_client.execute(local_var_req).await?;
2143
2144    let local_var_status = local_var_resp.status();
2145    let local_var_content = local_var_resp.text().await?;
2146
2147    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2148        serde_json::from_str(&local_var_content).map_err(Error::from)
2149    } else {
2150        let local_var_entity: Option<CoreDataSourcesCreateError> =
2151            serde_json::from_str(&local_var_content).ok();
2152        let local_var_error = ResponseContent {
2153            status: local_var_status,
2154            content: local_var_content,
2155            entity: local_var_entity,
2156        };
2157        Err(Error::ResponseError(local_var_error))
2158    }
2159}
2160
2161/// Delete a data source object.
2162pub async fn core_data_sources_destroy(
2163    configuration: &configuration::Configuration,
2164    id: i32,
2165) -> Result<(), Error<CoreDataSourcesDestroyError>> {
2166    let local_var_configuration = configuration;
2167
2168    let local_var_client = &local_var_configuration.client;
2169
2170    let local_var_uri_str = format!(
2171        "{}/api/core/data-sources/{id}/",
2172        local_var_configuration.base_path,
2173        id = id
2174    );
2175    let mut local_var_req_builder =
2176        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2177
2178    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2179        local_var_req_builder =
2180            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2181    }
2182    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2183        let local_var_key = local_var_apikey.key.clone();
2184        let local_var_value = match local_var_apikey.prefix {
2185            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2186            None => local_var_key,
2187        };
2188        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2189    };
2190
2191    let local_var_req = local_var_req_builder.build()?;
2192    let local_var_resp = local_var_client.execute(local_var_req).await?;
2193
2194    let local_var_status = local_var_resp.status();
2195    let local_var_content = local_var_resp.text().await?;
2196
2197    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2198        Ok(())
2199    } else {
2200        let local_var_entity: Option<CoreDataSourcesDestroyError> =
2201            serde_json::from_str(&local_var_content).ok();
2202        let local_var_error = ResponseContent {
2203            status: local_var_status,
2204            content: local_var_content,
2205            entity: local_var_entity,
2206        };
2207        Err(Error::ResponseError(local_var_error))
2208    }
2209}
2210
2211/// Get a list of data source objects.
2212pub async fn core_data_sources_list(
2213    configuration: &configuration::Configuration,
2214    created: Option<Vec<String>>,
2215    created__empty: Option<Vec<String>>,
2216    created__gt: Option<Vec<String>>,
2217    created__gte: Option<Vec<String>>,
2218    created__lt: Option<Vec<String>>,
2219    created__lte: Option<Vec<String>>,
2220    created__n: Option<Vec<String>>,
2221    created_by_request: Option<&str>,
2222    description: Option<Vec<String>>,
2223    description__empty: Option<bool>,
2224    description__ic: Option<Vec<String>>,
2225    description__ie: Option<Vec<String>>,
2226    description__iew: Option<Vec<String>>,
2227    description__iregex: Option<Vec<String>>,
2228    description__isw: Option<Vec<String>>,
2229    description__n: Option<Vec<String>>,
2230    description__nic: Option<Vec<String>>,
2231    description__nie: Option<Vec<String>>,
2232    description__niew: Option<Vec<String>>,
2233    description__nisw: Option<Vec<String>>,
2234    description__regex: Option<Vec<String>>,
2235    enabled: Option<bool>,
2236    id: Option<Vec<i32>>,
2237    id__empty: Option<bool>,
2238    id__gt: Option<Vec<i32>>,
2239    id__gte: Option<Vec<i32>>,
2240    id__lt: Option<Vec<i32>>,
2241    id__lte: Option<Vec<i32>>,
2242    id__n: Option<Vec<i32>>,
2243    last_synced: Option<Vec<String>>,
2244    last_synced__empty: Option<bool>,
2245    last_synced__gt: Option<Vec<String>>,
2246    last_synced__gte: Option<Vec<String>>,
2247    last_synced__lt: Option<Vec<String>>,
2248    last_synced__lte: Option<Vec<String>>,
2249    last_synced__n: Option<Vec<String>>,
2250    last_updated: Option<Vec<String>>,
2251    last_updated__empty: Option<Vec<String>>,
2252    last_updated__gt: Option<Vec<String>>,
2253    last_updated__gte: Option<Vec<String>>,
2254    last_updated__lt: Option<Vec<String>>,
2255    last_updated__lte: Option<Vec<String>>,
2256    last_updated__n: Option<Vec<String>>,
2257    limit: Option<i32>,
2258    modified_by_request: Option<&str>,
2259    name: Option<Vec<String>>,
2260    name__empty: Option<bool>,
2261    name__ic: Option<Vec<String>>,
2262    name__ie: Option<Vec<String>>,
2263    name__iew: Option<Vec<String>>,
2264    name__iregex: Option<Vec<String>>,
2265    name__isw: Option<Vec<String>>,
2266    name__n: Option<Vec<String>>,
2267    name__nic: Option<Vec<String>>,
2268    name__nie: Option<Vec<String>>,
2269    name__niew: Option<Vec<String>>,
2270    name__nisw: Option<Vec<String>>,
2271    name__regex: Option<Vec<String>>,
2272    offset: Option<i32>,
2273    ordering: Option<&str>,
2274    owner: Option<Vec<String>>,
2275    owner__n: Option<Vec<String>>,
2276    owner_group: Option<Vec<String>>,
2277    owner_group__n: Option<Vec<String>>,
2278    owner_group_id: Option<Vec<i32>>,
2279    owner_group_id__n: Option<Vec<i32>>,
2280    owner_id: Option<Vec<i32>>,
2281    owner_id__n: Option<Vec<i32>>,
2282    q: Option<&str>,
2283    source_url: Option<Vec<String>>,
2284    source_url__empty: Option<bool>,
2285    source_url__ic: Option<Vec<String>>,
2286    source_url__ie: Option<Vec<String>>,
2287    source_url__iew: Option<Vec<String>>,
2288    source_url__iregex: Option<Vec<String>>,
2289    source_url__isw: Option<Vec<String>>,
2290    source_url__n: Option<Vec<String>>,
2291    source_url__nic: Option<Vec<String>>,
2292    source_url__nie: Option<Vec<String>>,
2293    source_url__niew: Option<Vec<String>>,
2294    source_url__nisw: Option<Vec<String>>,
2295    source_url__regex: Option<Vec<String>>,
2296    status: Option<Vec<String>>,
2297    status__empty: Option<bool>,
2298    status__ic: Option<Vec<String>>,
2299    status__ie: Option<Vec<String>>,
2300    status__iew: Option<Vec<String>>,
2301    status__iregex: Option<Vec<String>>,
2302    status__isw: Option<Vec<String>>,
2303    status__n: Option<Vec<String>>,
2304    status__nic: Option<Vec<String>>,
2305    status__nie: Option<Vec<String>>,
2306    status__niew: Option<Vec<String>>,
2307    status__nisw: Option<Vec<String>>,
2308    status__regex: Option<Vec<String>>,
2309    sync_interval: Option<Vec<i32>>,
2310    sync_interval__ic: Option<Vec<i32>>,
2311    sync_interval__ie: Option<Vec<i32>>,
2312    sync_interval__iew: Option<Vec<i32>>,
2313    sync_interval__iregex: Option<Vec<i32>>,
2314    sync_interval__isw: Option<Vec<i32>>,
2315    sync_interval__n: Option<Vec<i32>>,
2316    sync_interval__nic: Option<Vec<i32>>,
2317    sync_interval__nie: Option<Vec<i32>>,
2318    sync_interval__niew: Option<Vec<i32>>,
2319    sync_interval__nisw: Option<Vec<i32>>,
2320    sync_interval__regex: Option<Vec<i32>>,
2321    tag: Option<Vec<String>>,
2322    tag__n: Option<Vec<String>>,
2323    tag_id: Option<Vec<i32>>,
2324    tag_id__n: Option<Vec<i32>>,
2325    r#type: Option<Vec<String>>,
2326    type__empty: Option<bool>,
2327    type__ic: Option<Vec<String>>,
2328    type__ie: Option<Vec<String>>,
2329    type__iew: Option<Vec<String>>,
2330    type__iregex: Option<Vec<String>>,
2331    type__isw: Option<Vec<String>>,
2332    type__n: Option<Vec<String>>,
2333    type__nic: Option<Vec<String>>,
2334    type__nie: Option<Vec<String>>,
2335    type__niew: Option<Vec<String>>,
2336    type__nisw: Option<Vec<String>>,
2337    type__regex: Option<Vec<String>>,
2338    updated_by_request: Option<&str>,
2339) -> Result<crate::models::PaginatedDataSourceList, Error<CoreDataSourcesListError>> {
2340    let local_var_configuration = configuration;
2341
2342    let local_var_client = &local_var_configuration.client;
2343
2344    let local_var_uri_str = format!(
2345        "{}/api/core/data-sources/",
2346        local_var_configuration.base_path
2347    );
2348    let mut local_var_req_builder =
2349        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2350
2351    if let Some(ref local_var_str) = created {
2352        local_var_req_builder = match "multi" {
2353            "multi" => local_var_req_builder.query(
2354                &local_var_str
2355                    .into_iter()
2356                    .map(|p| ("created".to_owned(), p.to_string()))
2357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2358            ),
2359            _ => local_var_req_builder.query(&[(
2360                "created",
2361                &local_var_str
2362                    .into_iter()
2363                    .map(|p| p.to_string())
2364                    .collect::<Vec<String>>()
2365                    .join(",")
2366                    .to_string(),
2367            )]),
2368        };
2369    }
2370    if let Some(ref local_var_str) = created__empty {
2371        local_var_req_builder = match "multi" {
2372            "multi" => local_var_req_builder.query(
2373                &local_var_str
2374                    .into_iter()
2375                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2377            ),
2378            _ => local_var_req_builder.query(&[(
2379                "created__empty",
2380                &local_var_str
2381                    .into_iter()
2382                    .map(|p| p.to_string())
2383                    .collect::<Vec<String>>()
2384                    .join(",")
2385                    .to_string(),
2386            )]),
2387        };
2388    }
2389    if let Some(ref local_var_str) = created__gt {
2390        local_var_req_builder = match "multi" {
2391            "multi" => local_var_req_builder.query(
2392                &local_var_str
2393                    .into_iter()
2394                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2396            ),
2397            _ => local_var_req_builder.query(&[(
2398                "created__gt",
2399                &local_var_str
2400                    .into_iter()
2401                    .map(|p| p.to_string())
2402                    .collect::<Vec<String>>()
2403                    .join(",")
2404                    .to_string(),
2405            )]),
2406        };
2407    }
2408    if let Some(ref local_var_str) = created__gte {
2409        local_var_req_builder = match "multi" {
2410            "multi" => local_var_req_builder.query(
2411                &local_var_str
2412                    .into_iter()
2413                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2415            ),
2416            _ => local_var_req_builder.query(&[(
2417                "created__gte",
2418                &local_var_str
2419                    .into_iter()
2420                    .map(|p| p.to_string())
2421                    .collect::<Vec<String>>()
2422                    .join(",")
2423                    .to_string(),
2424            )]),
2425        };
2426    }
2427    if let Some(ref local_var_str) = created__lt {
2428        local_var_req_builder = match "multi" {
2429            "multi" => local_var_req_builder.query(
2430                &local_var_str
2431                    .into_iter()
2432                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2434            ),
2435            _ => local_var_req_builder.query(&[(
2436                "created__lt",
2437                &local_var_str
2438                    .into_iter()
2439                    .map(|p| p.to_string())
2440                    .collect::<Vec<String>>()
2441                    .join(",")
2442                    .to_string(),
2443            )]),
2444        };
2445    }
2446    if let Some(ref local_var_str) = created__lte {
2447        local_var_req_builder = match "multi" {
2448            "multi" => local_var_req_builder.query(
2449                &local_var_str
2450                    .into_iter()
2451                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2453            ),
2454            _ => local_var_req_builder.query(&[(
2455                "created__lte",
2456                &local_var_str
2457                    .into_iter()
2458                    .map(|p| p.to_string())
2459                    .collect::<Vec<String>>()
2460                    .join(",")
2461                    .to_string(),
2462            )]),
2463        };
2464    }
2465    if let Some(ref local_var_str) = created__n {
2466        local_var_req_builder = match "multi" {
2467            "multi" => local_var_req_builder.query(
2468                &local_var_str
2469                    .into_iter()
2470                    .map(|p| ("created__n".to_owned(), p.to_string()))
2471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2472            ),
2473            _ => local_var_req_builder.query(&[(
2474                "created__n",
2475                &local_var_str
2476                    .into_iter()
2477                    .map(|p| p.to_string())
2478                    .collect::<Vec<String>>()
2479                    .join(",")
2480                    .to_string(),
2481            )]),
2482        };
2483    }
2484    if let Some(ref local_var_str) = created_by_request {
2485        local_var_req_builder =
2486            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2487    }
2488    if let Some(ref local_var_str) = description {
2489        local_var_req_builder = match "multi" {
2490            "multi" => local_var_req_builder.query(
2491                &local_var_str
2492                    .into_iter()
2493                    .map(|p| ("description".to_owned(), p.to_string()))
2494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2495            ),
2496            _ => local_var_req_builder.query(&[(
2497                "description",
2498                &local_var_str
2499                    .into_iter()
2500                    .map(|p| p.to_string())
2501                    .collect::<Vec<String>>()
2502                    .join(",")
2503                    .to_string(),
2504            )]),
2505        };
2506    }
2507    if let Some(ref local_var_str) = description__empty {
2508        local_var_req_builder =
2509            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2510    }
2511    if let Some(ref local_var_str) = description__ic {
2512        local_var_req_builder = match "multi" {
2513            "multi" => local_var_req_builder.query(
2514                &local_var_str
2515                    .into_iter()
2516                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2518            ),
2519            _ => local_var_req_builder.query(&[(
2520                "description__ic",
2521                &local_var_str
2522                    .into_iter()
2523                    .map(|p| p.to_string())
2524                    .collect::<Vec<String>>()
2525                    .join(",")
2526                    .to_string(),
2527            )]),
2528        };
2529    }
2530    if let Some(ref local_var_str) = description__ie {
2531        local_var_req_builder = match "multi" {
2532            "multi" => local_var_req_builder.query(
2533                &local_var_str
2534                    .into_iter()
2535                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2537            ),
2538            _ => local_var_req_builder.query(&[(
2539                "description__ie",
2540                &local_var_str
2541                    .into_iter()
2542                    .map(|p| p.to_string())
2543                    .collect::<Vec<String>>()
2544                    .join(",")
2545                    .to_string(),
2546            )]),
2547        };
2548    }
2549    if let Some(ref local_var_str) = description__iew {
2550        local_var_req_builder = match "multi" {
2551            "multi" => local_var_req_builder.query(
2552                &local_var_str
2553                    .into_iter()
2554                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2556            ),
2557            _ => local_var_req_builder.query(&[(
2558                "description__iew",
2559                &local_var_str
2560                    .into_iter()
2561                    .map(|p| p.to_string())
2562                    .collect::<Vec<String>>()
2563                    .join(",")
2564                    .to_string(),
2565            )]),
2566        };
2567    }
2568    if let Some(ref local_var_str) = description__iregex {
2569        local_var_req_builder = match "multi" {
2570            "multi" => local_var_req_builder.query(
2571                &local_var_str
2572                    .into_iter()
2573                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2575            ),
2576            _ => local_var_req_builder.query(&[(
2577                "description__iregex",
2578                &local_var_str
2579                    .into_iter()
2580                    .map(|p| p.to_string())
2581                    .collect::<Vec<String>>()
2582                    .join(",")
2583                    .to_string(),
2584            )]),
2585        };
2586    }
2587    if let Some(ref local_var_str) = description__isw {
2588        local_var_req_builder = match "multi" {
2589            "multi" => local_var_req_builder.query(
2590                &local_var_str
2591                    .into_iter()
2592                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2594            ),
2595            _ => local_var_req_builder.query(&[(
2596                "description__isw",
2597                &local_var_str
2598                    .into_iter()
2599                    .map(|p| p.to_string())
2600                    .collect::<Vec<String>>()
2601                    .join(",")
2602                    .to_string(),
2603            )]),
2604        };
2605    }
2606    if let Some(ref local_var_str) = description__n {
2607        local_var_req_builder = match "multi" {
2608            "multi" => local_var_req_builder.query(
2609                &local_var_str
2610                    .into_iter()
2611                    .map(|p| ("description__n".to_owned(), p.to_string()))
2612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2613            ),
2614            _ => local_var_req_builder.query(&[(
2615                "description__n",
2616                &local_var_str
2617                    .into_iter()
2618                    .map(|p| p.to_string())
2619                    .collect::<Vec<String>>()
2620                    .join(",")
2621                    .to_string(),
2622            )]),
2623        };
2624    }
2625    if let Some(ref local_var_str) = description__nic {
2626        local_var_req_builder = match "multi" {
2627            "multi" => local_var_req_builder.query(
2628                &local_var_str
2629                    .into_iter()
2630                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2632            ),
2633            _ => local_var_req_builder.query(&[(
2634                "description__nic",
2635                &local_var_str
2636                    .into_iter()
2637                    .map(|p| p.to_string())
2638                    .collect::<Vec<String>>()
2639                    .join(",")
2640                    .to_string(),
2641            )]),
2642        };
2643    }
2644    if let Some(ref local_var_str) = description__nie {
2645        local_var_req_builder = match "multi" {
2646            "multi" => local_var_req_builder.query(
2647                &local_var_str
2648                    .into_iter()
2649                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2651            ),
2652            _ => local_var_req_builder.query(&[(
2653                "description__nie",
2654                &local_var_str
2655                    .into_iter()
2656                    .map(|p| p.to_string())
2657                    .collect::<Vec<String>>()
2658                    .join(",")
2659                    .to_string(),
2660            )]),
2661        };
2662    }
2663    if let Some(ref local_var_str) = description__niew {
2664        local_var_req_builder = match "multi" {
2665            "multi" => local_var_req_builder.query(
2666                &local_var_str
2667                    .into_iter()
2668                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2670            ),
2671            _ => local_var_req_builder.query(&[(
2672                "description__niew",
2673                &local_var_str
2674                    .into_iter()
2675                    .map(|p| p.to_string())
2676                    .collect::<Vec<String>>()
2677                    .join(",")
2678                    .to_string(),
2679            )]),
2680        };
2681    }
2682    if let Some(ref local_var_str) = description__nisw {
2683        local_var_req_builder = match "multi" {
2684            "multi" => local_var_req_builder.query(
2685                &local_var_str
2686                    .into_iter()
2687                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2689            ),
2690            _ => local_var_req_builder.query(&[(
2691                "description__nisw",
2692                &local_var_str
2693                    .into_iter()
2694                    .map(|p| p.to_string())
2695                    .collect::<Vec<String>>()
2696                    .join(",")
2697                    .to_string(),
2698            )]),
2699        };
2700    }
2701    if let Some(ref local_var_str) = description__regex {
2702        local_var_req_builder = match "multi" {
2703            "multi" => local_var_req_builder.query(
2704                &local_var_str
2705                    .into_iter()
2706                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2708            ),
2709            _ => local_var_req_builder.query(&[(
2710                "description__regex",
2711                &local_var_str
2712                    .into_iter()
2713                    .map(|p| p.to_string())
2714                    .collect::<Vec<String>>()
2715                    .join(",")
2716                    .to_string(),
2717            )]),
2718        };
2719    }
2720    if let Some(ref local_var_str) = enabled {
2721        local_var_req_builder =
2722            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
2723    }
2724    if let Some(ref local_var_str) = id {
2725        local_var_req_builder = match "multi" {
2726            "multi" => local_var_req_builder.query(
2727                &local_var_str
2728                    .into_iter()
2729                    .map(|p| ("id".to_owned(), p.to_string()))
2730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2731            ),
2732            _ => local_var_req_builder.query(&[(
2733                "id",
2734                &local_var_str
2735                    .into_iter()
2736                    .map(|p| p.to_string())
2737                    .collect::<Vec<String>>()
2738                    .join(",")
2739                    .to_string(),
2740            )]),
2741        };
2742    }
2743    if let Some(ref local_var_str) = id__empty {
2744        local_var_req_builder =
2745            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2746    }
2747    if let Some(ref local_var_str) = id__gt {
2748        local_var_req_builder = match "multi" {
2749            "multi" => local_var_req_builder.query(
2750                &local_var_str
2751                    .into_iter()
2752                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2754            ),
2755            _ => local_var_req_builder.query(&[(
2756                "id__gt",
2757                &local_var_str
2758                    .into_iter()
2759                    .map(|p| p.to_string())
2760                    .collect::<Vec<String>>()
2761                    .join(",")
2762                    .to_string(),
2763            )]),
2764        };
2765    }
2766    if let Some(ref local_var_str) = id__gte {
2767        local_var_req_builder = match "multi" {
2768            "multi" => local_var_req_builder.query(
2769                &local_var_str
2770                    .into_iter()
2771                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2773            ),
2774            _ => local_var_req_builder.query(&[(
2775                "id__gte",
2776                &local_var_str
2777                    .into_iter()
2778                    .map(|p| p.to_string())
2779                    .collect::<Vec<String>>()
2780                    .join(",")
2781                    .to_string(),
2782            )]),
2783        };
2784    }
2785    if let Some(ref local_var_str) = id__lt {
2786        local_var_req_builder = match "multi" {
2787            "multi" => local_var_req_builder.query(
2788                &local_var_str
2789                    .into_iter()
2790                    .map(|p| ("id__lt".to_owned(), p.to_string()))
2791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2792            ),
2793            _ => local_var_req_builder.query(&[(
2794                "id__lt",
2795                &local_var_str
2796                    .into_iter()
2797                    .map(|p| p.to_string())
2798                    .collect::<Vec<String>>()
2799                    .join(",")
2800                    .to_string(),
2801            )]),
2802        };
2803    }
2804    if let Some(ref local_var_str) = id__lte {
2805        local_var_req_builder = match "multi" {
2806            "multi" => local_var_req_builder.query(
2807                &local_var_str
2808                    .into_iter()
2809                    .map(|p| ("id__lte".to_owned(), p.to_string()))
2810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2811            ),
2812            _ => local_var_req_builder.query(&[(
2813                "id__lte",
2814                &local_var_str
2815                    .into_iter()
2816                    .map(|p| p.to_string())
2817                    .collect::<Vec<String>>()
2818                    .join(",")
2819                    .to_string(),
2820            )]),
2821        };
2822    }
2823    if let Some(ref local_var_str) = id__n {
2824        local_var_req_builder = match "multi" {
2825            "multi" => local_var_req_builder.query(
2826                &local_var_str
2827                    .into_iter()
2828                    .map(|p| ("id__n".to_owned(), p.to_string()))
2829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2830            ),
2831            _ => local_var_req_builder.query(&[(
2832                "id__n",
2833                &local_var_str
2834                    .into_iter()
2835                    .map(|p| p.to_string())
2836                    .collect::<Vec<String>>()
2837                    .join(",")
2838                    .to_string(),
2839            )]),
2840        };
2841    }
2842    if let Some(ref local_var_str) = last_synced {
2843        local_var_req_builder = match "multi" {
2844            "multi" => local_var_req_builder.query(
2845                &local_var_str
2846                    .into_iter()
2847                    .map(|p| ("last_synced".to_owned(), p.to_string()))
2848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2849            ),
2850            _ => local_var_req_builder.query(&[(
2851                "last_synced",
2852                &local_var_str
2853                    .into_iter()
2854                    .map(|p| p.to_string())
2855                    .collect::<Vec<String>>()
2856                    .join(",")
2857                    .to_string(),
2858            )]),
2859        };
2860    }
2861    if let Some(ref local_var_str) = last_synced__empty {
2862        local_var_req_builder =
2863            local_var_req_builder.query(&[("last_synced__empty", &local_var_str.to_string())]);
2864    }
2865    if let Some(ref local_var_str) = last_synced__gt {
2866        local_var_req_builder = match "multi" {
2867            "multi" => local_var_req_builder.query(
2868                &local_var_str
2869                    .into_iter()
2870                    .map(|p| ("last_synced__gt".to_owned(), p.to_string()))
2871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2872            ),
2873            _ => local_var_req_builder.query(&[(
2874                "last_synced__gt",
2875                &local_var_str
2876                    .into_iter()
2877                    .map(|p| p.to_string())
2878                    .collect::<Vec<String>>()
2879                    .join(",")
2880                    .to_string(),
2881            )]),
2882        };
2883    }
2884    if let Some(ref local_var_str) = last_synced__gte {
2885        local_var_req_builder = match "multi" {
2886            "multi" => local_var_req_builder.query(
2887                &local_var_str
2888                    .into_iter()
2889                    .map(|p| ("last_synced__gte".to_owned(), p.to_string()))
2890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2891            ),
2892            _ => local_var_req_builder.query(&[(
2893                "last_synced__gte",
2894                &local_var_str
2895                    .into_iter()
2896                    .map(|p| p.to_string())
2897                    .collect::<Vec<String>>()
2898                    .join(",")
2899                    .to_string(),
2900            )]),
2901        };
2902    }
2903    if let Some(ref local_var_str) = last_synced__lt {
2904        local_var_req_builder = match "multi" {
2905            "multi" => local_var_req_builder.query(
2906                &local_var_str
2907                    .into_iter()
2908                    .map(|p| ("last_synced__lt".to_owned(), p.to_string()))
2909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2910            ),
2911            _ => local_var_req_builder.query(&[(
2912                "last_synced__lt",
2913                &local_var_str
2914                    .into_iter()
2915                    .map(|p| p.to_string())
2916                    .collect::<Vec<String>>()
2917                    .join(",")
2918                    .to_string(),
2919            )]),
2920        };
2921    }
2922    if let Some(ref local_var_str) = last_synced__lte {
2923        local_var_req_builder = match "multi" {
2924            "multi" => local_var_req_builder.query(
2925                &local_var_str
2926                    .into_iter()
2927                    .map(|p| ("last_synced__lte".to_owned(), p.to_string()))
2928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2929            ),
2930            _ => local_var_req_builder.query(&[(
2931                "last_synced__lte",
2932                &local_var_str
2933                    .into_iter()
2934                    .map(|p| p.to_string())
2935                    .collect::<Vec<String>>()
2936                    .join(",")
2937                    .to_string(),
2938            )]),
2939        };
2940    }
2941    if let Some(ref local_var_str) = last_synced__n {
2942        local_var_req_builder = match "multi" {
2943            "multi" => local_var_req_builder.query(
2944                &local_var_str
2945                    .into_iter()
2946                    .map(|p| ("last_synced__n".to_owned(), p.to_string()))
2947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2948            ),
2949            _ => local_var_req_builder.query(&[(
2950                "last_synced__n",
2951                &local_var_str
2952                    .into_iter()
2953                    .map(|p| p.to_string())
2954                    .collect::<Vec<String>>()
2955                    .join(",")
2956                    .to_string(),
2957            )]),
2958        };
2959    }
2960    if let Some(ref local_var_str) = last_updated {
2961        local_var_req_builder = match "multi" {
2962            "multi" => local_var_req_builder.query(
2963                &local_var_str
2964                    .into_iter()
2965                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2967            ),
2968            _ => local_var_req_builder.query(&[(
2969                "last_updated",
2970                &local_var_str
2971                    .into_iter()
2972                    .map(|p| p.to_string())
2973                    .collect::<Vec<String>>()
2974                    .join(",")
2975                    .to_string(),
2976            )]),
2977        };
2978    }
2979    if let Some(ref local_var_str) = last_updated__empty {
2980        local_var_req_builder = match "multi" {
2981            "multi" => local_var_req_builder.query(
2982                &local_var_str
2983                    .into_iter()
2984                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
2985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2986            ),
2987            _ => local_var_req_builder.query(&[(
2988                "last_updated__empty",
2989                &local_var_str
2990                    .into_iter()
2991                    .map(|p| p.to_string())
2992                    .collect::<Vec<String>>()
2993                    .join(",")
2994                    .to_string(),
2995            )]),
2996        };
2997    }
2998    if let Some(ref local_var_str) = last_updated__gt {
2999        local_var_req_builder = match "multi" {
3000            "multi" => local_var_req_builder.query(
3001                &local_var_str
3002                    .into_iter()
3003                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3005            ),
3006            _ => local_var_req_builder.query(&[(
3007                "last_updated__gt",
3008                &local_var_str
3009                    .into_iter()
3010                    .map(|p| p.to_string())
3011                    .collect::<Vec<String>>()
3012                    .join(",")
3013                    .to_string(),
3014            )]),
3015        };
3016    }
3017    if let Some(ref local_var_str) = last_updated__gte {
3018        local_var_req_builder = match "multi" {
3019            "multi" => local_var_req_builder.query(
3020                &local_var_str
3021                    .into_iter()
3022                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3024            ),
3025            _ => local_var_req_builder.query(&[(
3026                "last_updated__gte",
3027                &local_var_str
3028                    .into_iter()
3029                    .map(|p| p.to_string())
3030                    .collect::<Vec<String>>()
3031                    .join(",")
3032                    .to_string(),
3033            )]),
3034        };
3035    }
3036    if let Some(ref local_var_str) = last_updated__lt {
3037        local_var_req_builder = match "multi" {
3038            "multi" => local_var_req_builder.query(
3039                &local_var_str
3040                    .into_iter()
3041                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3043            ),
3044            _ => local_var_req_builder.query(&[(
3045                "last_updated__lt",
3046                &local_var_str
3047                    .into_iter()
3048                    .map(|p| p.to_string())
3049                    .collect::<Vec<String>>()
3050                    .join(",")
3051                    .to_string(),
3052            )]),
3053        };
3054    }
3055    if let Some(ref local_var_str) = last_updated__lte {
3056        local_var_req_builder = match "multi" {
3057            "multi" => local_var_req_builder.query(
3058                &local_var_str
3059                    .into_iter()
3060                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3062            ),
3063            _ => local_var_req_builder.query(&[(
3064                "last_updated__lte",
3065                &local_var_str
3066                    .into_iter()
3067                    .map(|p| p.to_string())
3068                    .collect::<Vec<String>>()
3069                    .join(",")
3070                    .to_string(),
3071            )]),
3072        };
3073    }
3074    if let Some(ref local_var_str) = last_updated__n {
3075        local_var_req_builder = match "multi" {
3076            "multi" => local_var_req_builder.query(
3077                &local_var_str
3078                    .into_iter()
3079                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3081            ),
3082            _ => local_var_req_builder.query(&[(
3083                "last_updated__n",
3084                &local_var_str
3085                    .into_iter()
3086                    .map(|p| p.to_string())
3087                    .collect::<Vec<String>>()
3088                    .join(",")
3089                    .to_string(),
3090            )]),
3091        };
3092    }
3093    if let Some(ref local_var_str) = limit {
3094        local_var_req_builder =
3095            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3096    }
3097    if let Some(ref local_var_str) = modified_by_request {
3098        local_var_req_builder =
3099            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3100    }
3101    if let Some(ref local_var_str) = name {
3102        local_var_req_builder = match "multi" {
3103            "multi" => local_var_req_builder.query(
3104                &local_var_str
3105                    .into_iter()
3106                    .map(|p| ("name".to_owned(), p.to_string()))
3107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3108            ),
3109            _ => local_var_req_builder.query(&[(
3110                "name",
3111                &local_var_str
3112                    .into_iter()
3113                    .map(|p| p.to_string())
3114                    .collect::<Vec<String>>()
3115                    .join(",")
3116                    .to_string(),
3117            )]),
3118        };
3119    }
3120    if let Some(ref local_var_str) = name__empty {
3121        local_var_req_builder =
3122            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3123    }
3124    if let Some(ref local_var_str) = name__ic {
3125        local_var_req_builder = match "multi" {
3126            "multi" => local_var_req_builder.query(
3127                &local_var_str
3128                    .into_iter()
3129                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3131            ),
3132            _ => local_var_req_builder.query(&[(
3133                "name__ic",
3134                &local_var_str
3135                    .into_iter()
3136                    .map(|p| p.to_string())
3137                    .collect::<Vec<String>>()
3138                    .join(",")
3139                    .to_string(),
3140            )]),
3141        };
3142    }
3143    if let Some(ref local_var_str) = name__ie {
3144        local_var_req_builder = match "multi" {
3145            "multi" => local_var_req_builder.query(
3146                &local_var_str
3147                    .into_iter()
3148                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3150            ),
3151            _ => local_var_req_builder.query(&[(
3152                "name__ie",
3153                &local_var_str
3154                    .into_iter()
3155                    .map(|p| p.to_string())
3156                    .collect::<Vec<String>>()
3157                    .join(",")
3158                    .to_string(),
3159            )]),
3160        };
3161    }
3162    if let Some(ref local_var_str) = name__iew {
3163        local_var_req_builder = match "multi" {
3164            "multi" => local_var_req_builder.query(
3165                &local_var_str
3166                    .into_iter()
3167                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3169            ),
3170            _ => local_var_req_builder.query(&[(
3171                "name__iew",
3172                &local_var_str
3173                    .into_iter()
3174                    .map(|p| p.to_string())
3175                    .collect::<Vec<String>>()
3176                    .join(",")
3177                    .to_string(),
3178            )]),
3179        };
3180    }
3181    if let Some(ref local_var_str) = name__iregex {
3182        local_var_req_builder = match "multi" {
3183            "multi" => local_var_req_builder.query(
3184                &local_var_str
3185                    .into_iter()
3186                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3188            ),
3189            _ => local_var_req_builder.query(&[(
3190                "name__iregex",
3191                &local_var_str
3192                    .into_iter()
3193                    .map(|p| p.to_string())
3194                    .collect::<Vec<String>>()
3195                    .join(",")
3196                    .to_string(),
3197            )]),
3198        };
3199    }
3200    if let Some(ref local_var_str) = name__isw {
3201        local_var_req_builder = match "multi" {
3202            "multi" => local_var_req_builder.query(
3203                &local_var_str
3204                    .into_iter()
3205                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3207            ),
3208            _ => local_var_req_builder.query(&[(
3209                "name__isw",
3210                &local_var_str
3211                    .into_iter()
3212                    .map(|p| p.to_string())
3213                    .collect::<Vec<String>>()
3214                    .join(",")
3215                    .to_string(),
3216            )]),
3217        };
3218    }
3219    if let Some(ref local_var_str) = name__n {
3220        local_var_req_builder = match "multi" {
3221            "multi" => local_var_req_builder.query(
3222                &local_var_str
3223                    .into_iter()
3224                    .map(|p| ("name__n".to_owned(), p.to_string()))
3225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3226            ),
3227            _ => local_var_req_builder.query(&[(
3228                "name__n",
3229                &local_var_str
3230                    .into_iter()
3231                    .map(|p| p.to_string())
3232                    .collect::<Vec<String>>()
3233                    .join(",")
3234                    .to_string(),
3235            )]),
3236        };
3237    }
3238    if let Some(ref local_var_str) = name__nic {
3239        local_var_req_builder = match "multi" {
3240            "multi" => local_var_req_builder.query(
3241                &local_var_str
3242                    .into_iter()
3243                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3245            ),
3246            _ => local_var_req_builder.query(&[(
3247                "name__nic",
3248                &local_var_str
3249                    .into_iter()
3250                    .map(|p| p.to_string())
3251                    .collect::<Vec<String>>()
3252                    .join(",")
3253                    .to_string(),
3254            )]),
3255        };
3256    }
3257    if let Some(ref local_var_str) = name__nie {
3258        local_var_req_builder = match "multi" {
3259            "multi" => local_var_req_builder.query(
3260                &local_var_str
3261                    .into_iter()
3262                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3264            ),
3265            _ => local_var_req_builder.query(&[(
3266                "name__nie",
3267                &local_var_str
3268                    .into_iter()
3269                    .map(|p| p.to_string())
3270                    .collect::<Vec<String>>()
3271                    .join(",")
3272                    .to_string(),
3273            )]),
3274        };
3275    }
3276    if let Some(ref local_var_str) = name__niew {
3277        local_var_req_builder = match "multi" {
3278            "multi" => local_var_req_builder.query(
3279                &local_var_str
3280                    .into_iter()
3281                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3283            ),
3284            _ => local_var_req_builder.query(&[(
3285                "name__niew",
3286                &local_var_str
3287                    .into_iter()
3288                    .map(|p| p.to_string())
3289                    .collect::<Vec<String>>()
3290                    .join(",")
3291                    .to_string(),
3292            )]),
3293        };
3294    }
3295    if let Some(ref local_var_str) = name__nisw {
3296        local_var_req_builder = match "multi" {
3297            "multi" => local_var_req_builder.query(
3298                &local_var_str
3299                    .into_iter()
3300                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3302            ),
3303            _ => local_var_req_builder.query(&[(
3304                "name__nisw",
3305                &local_var_str
3306                    .into_iter()
3307                    .map(|p| p.to_string())
3308                    .collect::<Vec<String>>()
3309                    .join(",")
3310                    .to_string(),
3311            )]),
3312        };
3313    }
3314    if let Some(ref local_var_str) = name__regex {
3315        local_var_req_builder = match "multi" {
3316            "multi" => local_var_req_builder.query(
3317                &local_var_str
3318                    .into_iter()
3319                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3321            ),
3322            _ => local_var_req_builder.query(&[(
3323                "name__regex",
3324                &local_var_str
3325                    .into_iter()
3326                    .map(|p| p.to_string())
3327                    .collect::<Vec<String>>()
3328                    .join(",")
3329                    .to_string(),
3330            )]),
3331        };
3332    }
3333    if let Some(ref local_var_str) = offset {
3334        local_var_req_builder =
3335            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3336    }
3337    if let Some(ref local_var_str) = ordering {
3338        local_var_req_builder =
3339            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3340    }
3341    if let Some(ref local_var_str) = owner {
3342        local_var_req_builder = match "multi" {
3343            "multi" => local_var_req_builder.query(
3344                &local_var_str
3345                    .into_iter()
3346                    .map(|p| ("owner".to_owned(), p.to_string()))
3347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3348            ),
3349            _ => local_var_req_builder.query(&[(
3350                "owner",
3351                &local_var_str
3352                    .into_iter()
3353                    .map(|p| p.to_string())
3354                    .collect::<Vec<String>>()
3355                    .join(",")
3356                    .to_string(),
3357            )]),
3358        };
3359    }
3360    if let Some(ref local_var_str) = owner__n {
3361        local_var_req_builder = match "multi" {
3362            "multi" => local_var_req_builder.query(
3363                &local_var_str
3364                    .into_iter()
3365                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3367            ),
3368            _ => local_var_req_builder.query(&[(
3369                "owner__n",
3370                &local_var_str
3371                    .into_iter()
3372                    .map(|p| p.to_string())
3373                    .collect::<Vec<String>>()
3374                    .join(",")
3375                    .to_string(),
3376            )]),
3377        };
3378    }
3379    if let Some(ref local_var_str) = owner_group {
3380        local_var_req_builder = match "multi" {
3381            "multi" => local_var_req_builder.query(
3382                &local_var_str
3383                    .into_iter()
3384                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3386            ),
3387            _ => local_var_req_builder.query(&[(
3388                "owner_group",
3389                &local_var_str
3390                    .into_iter()
3391                    .map(|p| p.to_string())
3392                    .collect::<Vec<String>>()
3393                    .join(",")
3394                    .to_string(),
3395            )]),
3396        };
3397    }
3398    if let Some(ref local_var_str) = owner_group__n {
3399        local_var_req_builder = match "multi" {
3400            "multi" => local_var_req_builder.query(
3401                &local_var_str
3402                    .into_iter()
3403                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3405            ),
3406            _ => local_var_req_builder.query(&[(
3407                "owner_group__n",
3408                &local_var_str
3409                    .into_iter()
3410                    .map(|p| p.to_string())
3411                    .collect::<Vec<String>>()
3412                    .join(",")
3413                    .to_string(),
3414            )]),
3415        };
3416    }
3417    if let Some(ref local_var_str) = owner_group_id {
3418        local_var_req_builder = match "multi" {
3419            "multi" => local_var_req_builder.query(
3420                &local_var_str
3421                    .into_iter()
3422                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3424            ),
3425            _ => local_var_req_builder.query(&[(
3426                "owner_group_id",
3427                &local_var_str
3428                    .into_iter()
3429                    .map(|p| p.to_string())
3430                    .collect::<Vec<String>>()
3431                    .join(",")
3432                    .to_string(),
3433            )]),
3434        };
3435    }
3436    if let Some(ref local_var_str) = owner_group_id__n {
3437        local_var_req_builder = match "multi" {
3438            "multi" => local_var_req_builder.query(
3439                &local_var_str
3440                    .into_iter()
3441                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3443            ),
3444            _ => local_var_req_builder.query(&[(
3445                "owner_group_id__n",
3446                &local_var_str
3447                    .into_iter()
3448                    .map(|p| p.to_string())
3449                    .collect::<Vec<String>>()
3450                    .join(",")
3451                    .to_string(),
3452            )]),
3453        };
3454    }
3455    if let Some(ref local_var_str) = owner_id {
3456        local_var_req_builder = match "multi" {
3457            "multi" => local_var_req_builder.query(
3458                &local_var_str
3459                    .into_iter()
3460                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3462            ),
3463            _ => local_var_req_builder.query(&[(
3464                "owner_id",
3465                &local_var_str
3466                    .into_iter()
3467                    .map(|p| p.to_string())
3468                    .collect::<Vec<String>>()
3469                    .join(",")
3470                    .to_string(),
3471            )]),
3472        };
3473    }
3474    if let Some(ref local_var_str) = owner_id__n {
3475        local_var_req_builder = match "multi" {
3476            "multi" => local_var_req_builder.query(
3477                &local_var_str
3478                    .into_iter()
3479                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3481            ),
3482            _ => local_var_req_builder.query(&[(
3483                "owner_id__n",
3484                &local_var_str
3485                    .into_iter()
3486                    .map(|p| p.to_string())
3487                    .collect::<Vec<String>>()
3488                    .join(",")
3489                    .to_string(),
3490            )]),
3491        };
3492    }
3493    if let Some(ref local_var_str) = q {
3494        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3495    }
3496    if let Some(ref local_var_str) = source_url {
3497        local_var_req_builder = match "multi" {
3498            "multi" => local_var_req_builder.query(
3499                &local_var_str
3500                    .into_iter()
3501                    .map(|p| ("source_url".to_owned(), p.to_string()))
3502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3503            ),
3504            _ => local_var_req_builder.query(&[(
3505                "source_url",
3506                &local_var_str
3507                    .into_iter()
3508                    .map(|p| p.to_string())
3509                    .collect::<Vec<String>>()
3510                    .join(",")
3511                    .to_string(),
3512            )]),
3513        };
3514    }
3515    if let Some(ref local_var_str) = source_url__empty {
3516        local_var_req_builder =
3517            local_var_req_builder.query(&[("source_url__empty", &local_var_str.to_string())]);
3518    }
3519    if let Some(ref local_var_str) = source_url__ic {
3520        local_var_req_builder = match "multi" {
3521            "multi" => local_var_req_builder.query(
3522                &local_var_str
3523                    .into_iter()
3524                    .map(|p| ("source_url__ic".to_owned(), p.to_string()))
3525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3526            ),
3527            _ => local_var_req_builder.query(&[(
3528                "source_url__ic",
3529                &local_var_str
3530                    .into_iter()
3531                    .map(|p| p.to_string())
3532                    .collect::<Vec<String>>()
3533                    .join(",")
3534                    .to_string(),
3535            )]),
3536        };
3537    }
3538    if let Some(ref local_var_str) = source_url__ie {
3539        local_var_req_builder = match "multi" {
3540            "multi" => local_var_req_builder.query(
3541                &local_var_str
3542                    .into_iter()
3543                    .map(|p| ("source_url__ie".to_owned(), p.to_string()))
3544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3545            ),
3546            _ => local_var_req_builder.query(&[(
3547                "source_url__ie",
3548                &local_var_str
3549                    .into_iter()
3550                    .map(|p| p.to_string())
3551                    .collect::<Vec<String>>()
3552                    .join(",")
3553                    .to_string(),
3554            )]),
3555        };
3556    }
3557    if let Some(ref local_var_str) = source_url__iew {
3558        local_var_req_builder = match "multi" {
3559            "multi" => local_var_req_builder.query(
3560                &local_var_str
3561                    .into_iter()
3562                    .map(|p| ("source_url__iew".to_owned(), p.to_string()))
3563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3564            ),
3565            _ => local_var_req_builder.query(&[(
3566                "source_url__iew",
3567                &local_var_str
3568                    .into_iter()
3569                    .map(|p| p.to_string())
3570                    .collect::<Vec<String>>()
3571                    .join(",")
3572                    .to_string(),
3573            )]),
3574        };
3575    }
3576    if let Some(ref local_var_str) = source_url__iregex {
3577        local_var_req_builder = match "multi" {
3578            "multi" => local_var_req_builder.query(
3579                &local_var_str
3580                    .into_iter()
3581                    .map(|p| ("source_url__iregex".to_owned(), p.to_string()))
3582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3583            ),
3584            _ => local_var_req_builder.query(&[(
3585                "source_url__iregex",
3586                &local_var_str
3587                    .into_iter()
3588                    .map(|p| p.to_string())
3589                    .collect::<Vec<String>>()
3590                    .join(",")
3591                    .to_string(),
3592            )]),
3593        };
3594    }
3595    if let Some(ref local_var_str) = source_url__isw {
3596        local_var_req_builder = match "multi" {
3597            "multi" => local_var_req_builder.query(
3598                &local_var_str
3599                    .into_iter()
3600                    .map(|p| ("source_url__isw".to_owned(), p.to_string()))
3601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3602            ),
3603            _ => local_var_req_builder.query(&[(
3604                "source_url__isw",
3605                &local_var_str
3606                    .into_iter()
3607                    .map(|p| p.to_string())
3608                    .collect::<Vec<String>>()
3609                    .join(",")
3610                    .to_string(),
3611            )]),
3612        };
3613    }
3614    if let Some(ref local_var_str) = source_url__n {
3615        local_var_req_builder = match "multi" {
3616            "multi" => local_var_req_builder.query(
3617                &local_var_str
3618                    .into_iter()
3619                    .map(|p| ("source_url__n".to_owned(), p.to_string()))
3620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3621            ),
3622            _ => local_var_req_builder.query(&[(
3623                "source_url__n",
3624                &local_var_str
3625                    .into_iter()
3626                    .map(|p| p.to_string())
3627                    .collect::<Vec<String>>()
3628                    .join(",")
3629                    .to_string(),
3630            )]),
3631        };
3632    }
3633    if let Some(ref local_var_str) = source_url__nic {
3634        local_var_req_builder = match "multi" {
3635            "multi" => local_var_req_builder.query(
3636                &local_var_str
3637                    .into_iter()
3638                    .map(|p| ("source_url__nic".to_owned(), p.to_string()))
3639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3640            ),
3641            _ => local_var_req_builder.query(&[(
3642                "source_url__nic",
3643                &local_var_str
3644                    .into_iter()
3645                    .map(|p| p.to_string())
3646                    .collect::<Vec<String>>()
3647                    .join(",")
3648                    .to_string(),
3649            )]),
3650        };
3651    }
3652    if let Some(ref local_var_str) = source_url__nie {
3653        local_var_req_builder = match "multi" {
3654            "multi" => local_var_req_builder.query(
3655                &local_var_str
3656                    .into_iter()
3657                    .map(|p| ("source_url__nie".to_owned(), p.to_string()))
3658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3659            ),
3660            _ => local_var_req_builder.query(&[(
3661                "source_url__nie",
3662                &local_var_str
3663                    .into_iter()
3664                    .map(|p| p.to_string())
3665                    .collect::<Vec<String>>()
3666                    .join(",")
3667                    .to_string(),
3668            )]),
3669        };
3670    }
3671    if let Some(ref local_var_str) = source_url__niew {
3672        local_var_req_builder = match "multi" {
3673            "multi" => local_var_req_builder.query(
3674                &local_var_str
3675                    .into_iter()
3676                    .map(|p| ("source_url__niew".to_owned(), p.to_string()))
3677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3678            ),
3679            _ => local_var_req_builder.query(&[(
3680                "source_url__niew",
3681                &local_var_str
3682                    .into_iter()
3683                    .map(|p| p.to_string())
3684                    .collect::<Vec<String>>()
3685                    .join(",")
3686                    .to_string(),
3687            )]),
3688        };
3689    }
3690    if let Some(ref local_var_str) = source_url__nisw {
3691        local_var_req_builder = match "multi" {
3692            "multi" => local_var_req_builder.query(
3693                &local_var_str
3694                    .into_iter()
3695                    .map(|p| ("source_url__nisw".to_owned(), p.to_string()))
3696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3697            ),
3698            _ => local_var_req_builder.query(&[(
3699                "source_url__nisw",
3700                &local_var_str
3701                    .into_iter()
3702                    .map(|p| p.to_string())
3703                    .collect::<Vec<String>>()
3704                    .join(",")
3705                    .to_string(),
3706            )]),
3707        };
3708    }
3709    if let Some(ref local_var_str) = source_url__regex {
3710        local_var_req_builder = match "multi" {
3711            "multi" => local_var_req_builder.query(
3712                &local_var_str
3713                    .into_iter()
3714                    .map(|p| ("source_url__regex".to_owned(), p.to_string()))
3715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3716            ),
3717            _ => local_var_req_builder.query(&[(
3718                "source_url__regex",
3719                &local_var_str
3720                    .into_iter()
3721                    .map(|p| p.to_string())
3722                    .collect::<Vec<String>>()
3723                    .join(",")
3724                    .to_string(),
3725            )]),
3726        };
3727    }
3728    if let Some(ref local_var_str) = status {
3729        local_var_req_builder = match "multi" {
3730            "multi" => local_var_req_builder.query(
3731                &local_var_str
3732                    .into_iter()
3733                    .map(|p| ("status".to_owned(), p.to_string()))
3734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3735            ),
3736            _ => local_var_req_builder.query(&[(
3737                "status",
3738                &local_var_str
3739                    .into_iter()
3740                    .map(|p| p.to_string())
3741                    .collect::<Vec<String>>()
3742                    .join(",")
3743                    .to_string(),
3744            )]),
3745        };
3746    }
3747    if let Some(ref local_var_str) = status__empty {
3748        local_var_req_builder =
3749            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
3750    }
3751    if let Some(ref local_var_str) = status__ic {
3752        local_var_req_builder = match "multi" {
3753            "multi" => local_var_req_builder.query(
3754                &local_var_str
3755                    .into_iter()
3756                    .map(|p| ("status__ic".to_owned(), p.to_string()))
3757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3758            ),
3759            _ => local_var_req_builder.query(&[(
3760                "status__ic",
3761                &local_var_str
3762                    .into_iter()
3763                    .map(|p| p.to_string())
3764                    .collect::<Vec<String>>()
3765                    .join(",")
3766                    .to_string(),
3767            )]),
3768        };
3769    }
3770    if let Some(ref local_var_str) = status__ie {
3771        local_var_req_builder = match "multi" {
3772            "multi" => local_var_req_builder.query(
3773                &local_var_str
3774                    .into_iter()
3775                    .map(|p| ("status__ie".to_owned(), p.to_string()))
3776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3777            ),
3778            _ => local_var_req_builder.query(&[(
3779                "status__ie",
3780                &local_var_str
3781                    .into_iter()
3782                    .map(|p| p.to_string())
3783                    .collect::<Vec<String>>()
3784                    .join(",")
3785                    .to_string(),
3786            )]),
3787        };
3788    }
3789    if let Some(ref local_var_str) = status__iew {
3790        local_var_req_builder = match "multi" {
3791            "multi" => local_var_req_builder.query(
3792                &local_var_str
3793                    .into_iter()
3794                    .map(|p| ("status__iew".to_owned(), p.to_string()))
3795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3796            ),
3797            _ => local_var_req_builder.query(&[(
3798                "status__iew",
3799                &local_var_str
3800                    .into_iter()
3801                    .map(|p| p.to_string())
3802                    .collect::<Vec<String>>()
3803                    .join(",")
3804                    .to_string(),
3805            )]),
3806        };
3807    }
3808    if let Some(ref local_var_str) = status__iregex {
3809        local_var_req_builder = match "multi" {
3810            "multi" => local_var_req_builder.query(
3811                &local_var_str
3812                    .into_iter()
3813                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
3814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3815            ),
3816            _ => local_var_req_builder.query(&[(
3817                "status__iregex",
3818                &local_var_str
3819                    .into_iter()
3820                    .map(|p| p.to_string())
3821                    .collect::<Vec<String>>()
3822                    .join(",")
3823                    .to_string(),
3824            )]),
3825        };
3826    }
3827    if let Some(ref local_var_str) = status__isw {
3828        local_var_req_builder = match "multi" {
3829            "multi" => local_var_req_builder.query(
3830                &local_var_str
3831                    .into_iter()
3832                    .map(|p| ("status__isw".to_owned(), p.to_string()))
3833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3834            ),
3835            _ => local_var_req_builder.query(&[(
3836                "status__isw",
3837                &local_var_str
3838                    .into_iter()
3839                    .map(|p| p.to_string())
3840                    .collect::<Vec<String>>()
3841                    .join(",")
3842                    .to_string(),
3843            )]),
3844        };
3845    }
3846    if let Some(ref local_var_str) = status__n {
3847        local_var_req_builder = match "multi" {
3848            "multi" => local_var_req_builder.query(
3849                &local_var_str
3850                    .into_iter()
3851                    .map(|p| ("status__n".to_owned(), p.to_string()))
3852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3853            ),
3854            _ => local_var_req_builder.query(&[(
3855                "status__n",
3856                &local_var_str
3857                    .into_iter()
3858                    .map(|p| p.to_string())
3859                    .collect::<Vec<String>>()
3860                    .join(",")
3861                    .to_string(),
3862            )]),
3863        };
3864    }
3865    if let Some(ref local_var_str) = status__nic {
3866        local_var_req_builder = match "multi" {
3867            "multi" => local_var_req_builder.query(
3868                &local_var_str
3869                    .into_iter()
3870                    .map(|p| ("status__nic".to_owned(), p.to_string()))
3871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3872            ),
3873            _ => local_var_req_builder.query(&[(
3874                "status__nic",
3875                &local_var_str
3876                    .into_iter()
3877                    .map(|p| p.to_string())
3878                    .collect::<Vec<String>>()
3879                    .join(",")
3880                    .to_string(),
3881            )]),
3882        };
3883    }
3884    if let Some(ref local_var_str) = status__nie {
3885        local_var_req_builder = match "multi" {
3886            "multi" => local_var_req_builder.query(
3887                &local_var_str
3888                    .into_iter()
3889                    .map(|p| ("status__nie".to_owned(), p.to_string()))
3890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3891            ),
3892            _ => local_var_req_builder.query(&[(
3893                "status__nie",
3894                &local_var_str
3895                    .into_iter()
3896                    .map(|p| p.to_string())
3897                    .collect::<Vec<String>>()
3898                    .join(",")
3899                    .to_string(),
3900            )]),
3901        };
3902    }
3903    if let Some(ref local_var_str) = status__niew {
3904        local_var_req_builder = match "multi" {
3905            "multi" => local_var_req_builder.query(
3906                &local_var_str
3907                    .into_iter()
3908                    .map(|p| ("status__niew".to_owned(), p.to_string()))
3909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3910            ),
3911            _ => local_var_req_builder.query(&[(
3912                "status__niew",
3913                &local_var_str
3914                    .into_iter()
3915                    .map(|p| p.to_string())
3916                    .collect::<Vec<String>>()
3917                    .join(",")
3918                    .to_string(),
3919            )]),
3920        };
3921    }
3922    if let Some(ref local_var_str) = status__nisw {
3923        local_var_req_builder = match "multi" {
3924            "multi" => local_var_req_builder.query(
3925                &local_var_str
3926                    .into_iter()
3927                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
3928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3929            ),
3930            _ => local_var_req_builder.query(&[(
3931                "status__nisw",
3932                &local_var_str
3933                    .into_iter()
3934                    .map(|p| p.to_string())
3935                    .collect::<Vec<String>>()
3936                    .join(",")
3937                    .to_string(),
3938            )]),
3939        };
3940    }
3941    if let Some(ref local_var_str) = status__regex {
3942        local_var_req_builder = match "multi" {
3943            "multi" => local_var_req_builder.query(
3944                &local_var_str
3945                    .into_iter()
3946                    .map(|p| ("status__regex".to_owned(), p.to_string()))
3947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3948            ),
3949            _ => local_var_req_builder.query(&[(
3950                "status__regex",
3951                &local_var_str
3952                    .into_iter()
3953                    .map(|p| p.to_string())
3954                    .collect::<Vec<String>>()
3955                    .join(",")
3956                    .to_string(),
3957            )]),
3958        };
3959    }
3960    if let Some(ref local_var_str) = sync_interval {
3961        local_var_req_builder = match "multi" {
3962            "multi" => local_var_req_builder.query(
3963                &local_var_str
3964                    .into_iter()
3965                    .map(|p| ("sync_interval".to_owned(), p.to_string()))
3966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3967            ),
3968            _ => local_var_req_builder.query(&[(
3969                "sync_interval",
3970                &local_var_str
3971                    .into_iter()
3972                    .map(|p| p.to_string())
3973                    .collect::<Vec<String>>()
3974                    .join(",")
3975                    .to_string(),
3976            )]),
3977        };
3978    }
3979    if let Some(ref local_var_str) = sync_interval__ic {
3980        local_var_req_builder = match "multi" {
3981            "multi" => local_var_req_builder.query(
3982                &local_var_str
3983                    .into_iter()
3984                    .map(|p| ("sync_interval__ic".to_owned(), p.to_string()))
3985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3986            ),
3987            _ => local_var_req_builder.query(&[(
3988                "sync_interval__ic",
3989                &local_var_str
3990                    .into_iter()
3991                    .map(|p| p.to_string())
3992                    .collect::<Vec<String>>()
3993                    .join(",")
3994                    .to_string(),
3995            )]),
3996        };
3997    }
3998    if let Some(ref local_var_str) = sync_interval__ie {
3999        local_var_req_builder = match "multi" {
4000            "multi" => local_var_req_builder.query(
4001                &local_var_str
4002                    .into_iter()
4003                    .map(|p| ("sync_interval__ie".to_owned(), p.to_string()))
4004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4005            ),
4006            _ => local_var_req_builder.query(&[(
4007                "sync_interval__ie",
4008                &local_var_str
4009                    .into_iter()
4010                    .map(|p| p.to_string())
4011                    .collect::<Vec<String>>()
4012                    .join(",")
4013                    .to_string(),
4014            )]),
4015        };
4016    }
4017    if let Some(ref local_var_str) = sync_interval__iew {
4018        local_var_req_builder = match "multi" {
4019            "multi" => local_var_req_builder.query(
4020                &local_var_str
4021                    .into_iter()
4022                    .map(|p| ("sync_interval__iew".to_owned(), p.to_string()))
4023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4024            ),
4025            _ => local_var_req_builder.query(&[(
4026                "sync_interval__iew",
4027                &local_var_str
4028                    .into_iter()
4029                    .map(|p| p.to_string())
4030                    .collect::<Vec<String>>()
4031                    .join(",")
4032                    .to_string(),
4033            )]),
4034        };
4035    }
4036    if let Some(ref local_var_str) = sync_interval__iregex {
4037        local_var_req_builder = match "multi" {
4038            "multi" => local_var_req_builder.query(
4039                &local_var_str
4040                    .into_iter()
4041                    .map(|p| ("sync_interval__iregex".to_owned(), p.to_string()))
4042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4043            ),
4044            _ => local_var_req_builder.query(&[(
4045                "sync_interval__iregex",
4046                &local_var_str
4047                    .into_iter()
4048                    .map(|p| p.to_string())
4049                    .collect::<Vec<String>>()
4050                    .join(",")
4051                    .to_string(),
4052            )]),
4053        };
4054    }
4055    if let Some(ref local_var_str) = sync_interval__isw {
4056        local_var_req_builder = match "multi" {
4057            "multi" => local_var_req_builder.query(
4058                &local_var_str
4059                    .into_iter()
4060                    .map(|p| ("sync_interval__isw".to_owned(), p.to_string()))
4061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4062            ),
4063            _ => local_var_req_builder.query(&[(
4064                "sync_interval__isw",
4065                &local_var_str
4066                    .into_iter()
4067                    .map(|p| p.to_string())
4068                    .collect::<Vec<String>>()
4069                    .join(",")
4070                    .to_string(),
4071            )]),
4072        };
4073    }
4074    if let Some(ref local_var_str) = sync_interval__n {
4075        local_var_req_builder = match "multi" {
4076            "multi" => local_var_req_builder.query(
4077                &local_var_str
4078                    .into_iter()
4079                    .map(|p| ("sync_interval__n".to_owned(), p.to_string()))
4080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4081            ),
4082            _ => local_var_req_builder.query(&[(
4083                "sync_interval__n",
4084                &local_var_str
4085                    .into_iter()
4086                    .map(|p| p.to_string())
4087                    .collect::<Vec<String>>()
4088                    .join(",")
4089                    .to_string(),
4090            )]),
4091        };
4092    }
4093    if let Some(ref local_var_str) = sync_interval__nic {
4094        local_var_req_builder = match "multi" {
4095            "multi" => local_var_req_builder.query(
4096                &local_var_str
4097                    .into_iter()
4098                    .map(|p| ("sync_interval__nic".to_owned(), p.to_string()))
4099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4100            ),
4101            _ => local_var_req_builder.query(&[(
4102                "sync_interval__nic",
4103                &local_var_str
4104                    .into_iter()
4105                    .map(|p| p.to_string())
4106                    .collect::<Vec<String>>()
4107                    .join(",")
4108                    .to_string(),
4109            )]),
4110        };
4111    }
4112    if let Some(ref local_var_str) = sync_interval__nie {
4113        local_var_req_builder = match "multi" {
4114            "multi" => local_var_req_builder.query(
4115                &local_var_str
4116                    .into_iter()
4117                    .map(|p| ("sync_interval__nie".to_owned(), p.to_string()))
4118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4119            ),
4120            _ => local_var_req_builder.query(&[(
4121                "sync_interval__nie",
4122                &local_var_str
4123                    .into_iter()
4124                    .map(|p| p.to_string())
4125                    .collect::<Vec<String>>()
4126                    .join(",")
4127                    .to_string(),
4128            )]),
4129        };
4130    }
4131    if let Some(ref local_var_str) = sync_interval__niew {
4132        local_var_req_builder = match "multi" {
4133            "multi" => local_var_req_builder.query(
4134                &local_var_str
4135                    .into_iter()
4136                    .map(|p| ("sync_interval__niew".to_owned(), p.to_string()))
4137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4138            ),
4139            _ => local_var_req_builder.query(&[(
4140                "sync_interval__niew",
4141                &local_var_str
4142                    .into_iter()
4143                    .map(|p| p.to_string())
4144                    .collect::<Vec<String>>()
4145                    .join(",")
4146                    .to_string(),
4147            )]),
4148        };
4149    }
4150    if let Some(ref local_var_str) = sync_interval__nisw {
4151        local_var_req_builder = match "multi" {
4152            "multi" => local_var_req_builder.query(
4153                &local_var_str
4154                    .into_iter()
4155                    .map(|p| ("sync_interval__nisw".to_owned(), p.to_string()))
4156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4157            ),
4158            _ => local_var_req_builder.query(&[(
4159                "sync_interval__nisw",
4160                &local_var_str
4161                    .into_iter()
4162                    .map(|p| p.to_string())
4163                    .collect::<Vec<String>>()
4164                    .join(",")
4165                    .to_string(),
4166            )]),
4167        };
4168    }
4169    if let Some(ref local_var_str) = sync_interval__regex {
4170        local_var_req_builder = match "multi" {
4171            "multi" => local_var_req_builder.query(
4172                &local_var_str
4173                    .into_iter()
4174                    .map(|p| ("sync_interval__regex".to_owned(), p.to_string()))
4175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4176            ),
4177            _ => local_var_req_builder.query(&[(
4178                "sync_interval__regex",
4179                &local_var_str
4180                    .into_iter()
4181                    .map(|p| p.to_string())
4182                    .collect::<Vec<String>>()
4183                    .join(",")
4184                    .to_string(),
4185            )]),
4186        };
4187    }
4188    if let Some(ref local_var_str) = tag {
4189        local_var_req_builder = match "multi" {
4190            "multi" => local_var_req_builder.query(
4191                &local_var_str
4192                    .into_iter()
4193                    .map(|p| ("tag".to_owned(), p.to_string()))
4194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4195            ),
4196            _ => local_var_req_builder.query(&[(
4197                "tag",
4198                &local_var_str
4199                    .into_iter()
4200                    .map(|p| p.to_string())
4201                    .collect::<Vec<String>>()
4202                    .join(",")
4203                    .to_string(),
4204            )]),
4205        };
4206    }
4207    if let Some(ref local_var_str) = tag__n {
4208        local_var_req_builder = match "multi" {
4209            "multi" => local_var_req_builder.query(
4210                &local_var_str
4211                    .into_iter()
4212                    .map(|p| ("tag__n".to_owned(), p.to_string()))
4213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4214            ),
4215            _ => local_var_req_builder.query(&[(
4216                "tag__n",
4217                &local_var_str
4218                    .into_iter()
4219                    .map(|p| p.to_string())
4220                    .collect::<Vec<String>>()
4221                    .join(",")
4222                    .to_string(),
4223            )]),
4224        };
4225    }
4226    if let Some(ref local_var_str) = tag_id {
4227        local_var_req_builder = match "multi" {
4228            "multi" => local_var_req_builder.query(
4229                &local_var_str
4230                    .into_iter()
4231                    .map(|p| ("tag_id".to_owned(), p.to_string()))
4232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4233            ),
4234            _ => local_var_req_builder.query(&[(
4235                "tag_id",
4236                &local_var_str
4237                    .into_iter()
4238                    .map(|p| p.to_string())
4239                    .collect::<Vec<String>>()
4240                    .join(",")
4241                    .to_string(),
4242            )]),
4243        };
4244    }
4245    if let Some(ref local_var_str) = tag_id__n {
4246        local_var_req_builder = match "multi" {
4247            "multi" => local_var_req_builder.query(
4248                &local_var_str
4249                    .into_iter()
4250                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
4251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4252            ),
4253            _ => local_var_req_builder.query(&[(
4254                "tag_id__n",
4255                &local_var_str
4256                    .into_iter()
4257                    .map(|p| p.to_string())
4258                    .collect::<Vec<String>>()
4259                    .join(",")
4260                    .to_string(),
4261            )]),
4262        };
4263    }
4264    if let Some(ref local_var_str) = r#type {
4265        local_var_req_builder = match "multi" {
4266            "multi" => local_var_req_builder.query(
4267                &local_var_str
4268                    .into_iter()
4269                    .map(|p| ("type".to_owned(), p.to_string()))
4270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4271            ),
4272            _ => local_var_req_builder.query(&[(
4273                "type",
4274                &local_var_str
4275                    .into_iter()
4276                    .map(|p| p.to_string())
4277                    .collect::<Vec<String>>()
4278                    .join(",")
4279                    .to_string(),
4280            )]),
4281        };
4282    }
4283    if let Some(ref local_var_str) = type__empty {
4284        local_var_req_builder =
4285            local_var_req_builder.query(&[("type__empty", &local_var_str.to_string())]);
4286    }
4287    if let Some(ref local_var_str) = type__ic {
4288        local_var_req_builder = match "multi" {
4289            "multi" => local_var_req_builder.query(
4290                &local_var_str
4291                    .into_iter()
4292                    .map(|p| ("type__ic".to_owned(), p.to_string()))
4293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4294            ),
4295            _ => local_var_req_builder.query(&[(
4296                "type__ic",
4297                &local_var_str
4298                    .into_iter()
4299                    .map(|p| p.to_string())
4300                    .collect::<Vec<String>>()
4301                    .join(",")
4302                    .to_string(),
4303            )]),
4304        };
4305    }
4306    if let Some(ref local_var_str) = type__ie {
4307        local_var_req_builder = match "multi" {
4308            "multi" => local_var_req_builder.query(
4309                &local_var_str
4310                    .into_iter()
4311                    .map(|p| ("type__ie".to_owned(), p.to_string()))
4312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4313            ),
4314            _ => local_var_req_builder.query(&[(
4315                "type__ie",
4316                &local_var_str
4317                    .into_iter()
4318                    .map(|p| p.to_string())
4319                    .collect::<Vec<String>>()
4320                    .join(",")
4321                    .to_string(),
4322            )]),
4323        };
4324    }
4325    if let Some(ref local_var_str) = type__iew {
4326        local_var_req_builder = match "multi" {
4327            "multi" => local_var_req_builder.query(
4328                &local_var_str
4329                    .into_iter()
4330                    .map(|p| ("type__iew".to_owned(), p.to_string()))
4331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4332            ),
4333            _ => local_var_req_builder.query(&[(
4334                "type__iew",
4335                &local_var_str
4336                    .into_iter()
4337                    .map(|p| p.to_string())
4338                    .collect::<Vec<String>>()
4339                    .join(",")
4340                    .to_string(),
4341            )]),
4342        };
4343    }
4344    if let Some(ref local_var_str) = type__iregex {
4345        local_var_req_builder = match "multi" {
4346            "multi" => local_var_req_builder.query(
4347                &local_var_str
4348                    .into_iter()
4349                    .map(|p| ("type__iregex".to_owned(), p.to_string()))
4350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4351            ),
4352            _ => local_var_req_builder.query(&[(
4353                "type__iregex",
4354                &local_var_str
4355                    .into_iter()
4356                    .map(|p| p.to_string())
4357                    .collect::<Vec<String>>()
4358                    .join(",")
4359                    .to_string(),
4360            )]),
4361        };
4362    }
4363    if let Some(ref local_var_str) = type__isw {
4364        local_var_req_builder = match "multi" {
4365            "multi" => local_var_req_builder.query(
4366                &local_var_str
4367                    .into_iter()
4368                    .map(|p| ("type__isw".to_owned(), p.to_string()))
4369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4370            ),
4371            _ => local_var_req_builder.query(&[(
4372                "type__isw",
4373                &local_var_str
4374                    .into_iter()
4375                    .map(|p| p.to_string())
4376                    .collect::<Vec<String>>()
4377                    .join(",")
4378                    .to_string(),
4379            )]),
4380        };
4381    }
4382    if let Some(ref local_var_str) = type__n {
4383        local_var_req_builder = match "multi" {
4384            "multi" => local_var_req_builder.query(
4385                &local_var_str
4386                    .into_iter()
4387                    .map(|p| ("type__n".to_owned(), p.to_string()))
4388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4389            ),
4390            _ => local_var_req_builder.query(&[(
4391                "type__n",
4392                &local_var_str
4393                    .into_iter()
4394                    .map(|p| p.to_string())
4395                    .collect::<Vec<String>>()
4396                    .join(",")
4397                    .to_string(),
4398            )]),
4399        };
4400    }
4401    if let Some(ref local_var_str) = type__nic {
4402        local_var_req_builder = match "multi" {
4403            "multi" => local_var_req_builder.query(
4404                &local_var_str
4405                    .into_iter()
4406                    .map(|p| ("type__nic".to_owned(), p.to_string()))
4407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4408            ),
4409            _ => local_var_req_builder.query(&[(
4410                "type__nic",
4411                &local_var_str
4412                    .into_iter()
4413                    .map(|p| p.to_string())
4414                    .collect::<Vec<String>>()
4415                    .join(",")
4416                    .to_string(),
4417            )]),
4418        };
4419    }
4420    if let Some(ref local_var_str) = type__nie {
4421        local_var_req_builder = match "multi" {
4422            "multi" => local_var_req_builder.query(
4423                &local_var_str
4424                    .into_iter()
4425                    .map(|p| ("type__nie".to_owned(), p.to_string()))
4426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4427            ),
4428            _ => local_var_req_builder.query(&[(
4429                "type__nie",
4430                &local_var_str
4431                    .into_iter()
4432                    .map(|p| p.to_string())
4433                    .collect::<Vec<String>>()
4434                    .join(",")
4435                    .to_string(),
4436            )]),
4437        };
4438    }
4439    if let Some(ref local_var_str) = type__niew {
4440        local_var_req_builder = match "multi" {
4441            "multi" => local_var_req_builder.query(
4442                &local_var_str
4443                    .into_iter()
4444                    .map(|p| ("type__niew".to_owned(), p.to_string()))
4445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4446            ),
4447            _ => local_var_req_builder.query(&[(
4448                "type__niew",
4449                &local_var_str
4450                    .into_iter()
4451                    .map(|p| p.to_string())
4452                    .collect::<Vec<String>>()
4453                    .join(",")
4454                    .to_string(),
4455            )]),
4456        };
4457    }
4458    if let Some(ref local_var_str) = type__nisw {
4459        local_var_req_builder = match "multi" {
4460            "multi" => local_var_req_builder.query(
4461                &local_var_str
4462                    .into_iter()
4463                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
4464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4465            ),
4466            _ => local_var_req_builder.query(&[(
4467                "type__nisw",
4468                &local_var_str
4469                    .into_iter()
4470                    .map(|p| p.to_string())
4471                    .collect::<Vec<String>>()
4472                    .join(",")
4473                    .to_string(),
4474            )]),
4475        };
4476    }
4477    if let Some(ref local_var_str) = type__regex {
4478        local_var_req_builder = match "multi" {
4479            "multi" => local_var_req_builder.query(
4480                &local_var_str
4481                    .into_iter()
4482                    .map(|p| ("type__regex".to_owned(), p.to_string()))
4483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4484            ),
4485            _ => local_var_req_builder.query(&[(
4486                "type__regex",
4487                &local_var_str
4488                    .into_iter()
4489                    .map(|p| p.to_string())
4490                    .collect::<Vec<String>>()
4491                    .join(",")
4492                    .to_string(),
4493            )]),
4494        };
4495    }
4496    if let Some(ref local_var_str) = updated_by_request {
4497        local_var_req_builder =
4498            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
4499    }
4500    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4501        local_var_req_builder =
4502            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4503    }
4504    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4505        let local_var_key = local_var_apikey.key.clone();
4506        let local_var_value = match local_var_apikey.prefix {
4507            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4508            None => local_var_key,
4509        };
4510        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4511    };
4512
4513    let local_var_req = local_var_req_builder.build()?;
4514    let local_var_resp = local_var_client.execute(local_var_req).await?;
4515
4516    let local_var_status = local_var_resp.status();
4517    let local_var_content = local_var_resp.text().await?;
4518
4519    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4520        serde_json::from_str(&local_var_content).map_err(Error::from)
4521    } else {
4522        let local_var_entity: Option<CoreDataSourcesListError> =
4523            serde_json::from_str(&local_var_content).ok();
4524        let local_var_error = ResponseContent {
4525            status: local_var_status,
4526            content: local_var_content,
4527            entity: local_var_entity,
4528        };
4529        Err(Error::ResponseError(local_var_error))
4530    }
4531}
4532
4533/// Patch a data source object.
4534pub async fn core_data_sources_partial_update(
4535    configuration: &configuration::Configuration,
4536    id: i32,
4537    patched_writable_data_source_request: Option<crate::models::PatchedWritableDataSourceRequest>,
4538) -> Result<crate::models::DataSource, Error<CoreDataSourcesPartialUpdateError>> {
4539    let local_var_configuration = configuration;
4540
4541    let local_var_client = &local_var_configuration.client;
4542
4543    let local_var_uri_str = format!(
4544        "{}/api/core/data-sources/{id}/",
4545        local_var_configuration.base_path,
4546        id = id
4547    );
4548    let mut local_var_req_builder =
4549        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4550
4551    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4552        local_var_req_builder =
4553            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4554    }
4555    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4556        let local_var_key = local_var_apikey.key.clone();
4557        let local_var_value = match local_var_apikey.prefix {
4558            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4559            None => local_var_key,
4560        };
4561        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4562    };
4563    local_var_req_builder = local_var_req_builder.json(&patched_writable_data_source_request);
4564
4565    let local_var_req = local_var_req_builder.build()?;
4566    let local_var_resp = local_var_client.execute(local_var_req).await?;
4567
4568    let local_var_status = local_var_resp.status();
4569    let local_var_content = local_var_resp.text().await?;
4570
4571    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4572        serde_json::from_str(&local_var_content).map_err(Error::from)
4573    } else {
4574        let local_var_entity: Option<CoreDataSourcesPartialUpdateError> =
4575            serde_json::from_str(&local_var_content).ok();
4576        let local_var_error = ResponseContent {
4577            status: local_var_status,
4578            content: local_var_content,
4579            entity: local_var_entity,
4580        };
4581        Err(Error::ResponseError(local_var_error))
4582    }
4583}
4584
4585/// Get a data source object.
4586pub async fn core_data_sources_retrieve(
4587    configuration: &configuration::Configuration,
4588    id: i32,
4589) -> Result<crate::models::DataSource, Error<CoreDataSourcesRetrieveError>> {
4590    let local_var_configuration = configuration;
4591
4592    let local_var_client = &local_var_configuration.client;
4593
4594    let local_var_uri_str = format!(
4595        "{}/api/core/data-sources/{id}/",
4596        local_var_configuration.base_path,
4597        id = id
4598    );
4599    let mut local_var_req_builder =
4600        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4601
4602    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4603        local_var_req_builder =
4604            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4605    }
4606    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4607        let local_var_key = local_var_apikey.key.clone();
4608        let local_var_value = match local_var_apikey.prefix {
4609            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4610            None => local_var_key,
4611        };
4612        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4613    };
4614
4615    let local_var_req = local_var_req_builder.build()?;
4616    let local_var_resp = local_var_client.execute(local_var_req).await?;
4617
4618    let local_var_status = local_var_resp.status();
4619    let local_var_content = local_var_resp.text().await?;
4620
4621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4622        serde_json::from_str(&local_var_content).map_err(Error::from)
4623    } else {
4624        let local_var_entity: Option<CoreDataSourcesRetrieveError> =
4625            serde_json::from_str(&local_var_content).ok();
4626        let local_var_error = ResponseContent {
4627            status: local_var_status,
4628            content: local_var_content,
4629            entity: local_var_entity,
4630        };
4631        Err(Error::ResponseError(local_var_error))
4632    }
4633}
4634
4635/// Enqueue a job to synchronize the DataSource.
4636pub async fn core_data_sources_sync_create(
4637    configuration: &configuration::Configuration,
4638    id: i32,
4639    writable_data_source_request: crate::models::WritableDataSourceRequest,
4640) -> Result<crate::models::DataSource, Error<CoreDataSourcesSyncCreateError>> {
4641    let local_var_configuration = configuration;
4642
4643    let local_var_client = &local_var_configuration.client;
4644
4645    let local_var_uri_str = format!(
4646        "{}/api/core/data-sources/{id}/sync/",
4647        local_var_configuration.base_path,
4648        id = id
4649    );
4650    let mut local_var_req_builder =
4651        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4652
4653    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4654        local_var_req_builder =
4655            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4656    }
4657    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4658        let local_var_key = local_var_apikey.key.clone();
4659        let local_var_value = match local_var_apikey.prefix {
4660            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4661            None => local_var_key,
4662        };
4663        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4664    };
4665    local_var_req_builder = local_var_req_builder.json(&writable_data_source_request);
4666
4667    let local_var_req = local_var_req_builder.build()?;
4668    let local_var_resp = local_var_client.execute(local_var_req).await?;
4669
4670    let local_var_status = local_var_resp.status();
4671    let local_var_content = local_var_resp.text().await?;
4672
4673    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4674        serde_json::from_str(&local_var_content).map_err(Error::from)
4675    } else {
4676        let local_var_entity: Option<CoreDataSourcesSyncCreateError> =
4677            serde_json::from_str(&local_var_content).ok();
4678        let local_var_error = ResponseContent {
4679            status: local_var_status,
4680            content: local_var_content,
4681            entity: local_var_entity,
4682        };
4683        Err(Error::ResponseError(local_var_error))
4684    }
4685}
4686
4687/// Put a data source object.
4688pub async fn core_data_sources_update(
4689    configuration: &configuration::Configuration,
4690    id: i32,
4691    writable_data_source_request: crate::models::WritableDataSourceRequest,
4692) -> Result<crate::models::DataSource, Error<CoreDataSourcesUpdateError>> {
4693    let local_var_configuration = configuration;
4694
4695    let local_var_client = &local_var_configuration.client;
4696
4697    let local_var_uri_str = format!(
4698        "{}/api/core/data-sources/{id}/",
4699        local_var_configuration.base_path,
4700        id = id
4701    );
4702    let mut local_var_req_builder =
4703        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4704
4705    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4706        local_var_req_builder =
4707            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4708    }
4709    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4710        let local_var_key = local_var_apikey.key.clone();
4711        let local_var_value = match local_var_apikey.prefix {
4712            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4713            None => local_var_key,
4714        };
4715        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4716    };
4717    local_var_req_builder = local_var_req_builder.json(&writable_data_source_request);
4718
4719    let local_var_req = local_var_req_builder.build()?;
4720    let local_var_resp = local_var_client.execute(local_var_req).await?;
4721
4722    let local_var_status = local_var_resp.status();
4723    let local_var_content = local_var_resp.text().await?;
4724
4725    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4726        serde_json::from_str(&local_var_content).map_err(Error::from)
4727    } else {
4728        let local_var_entity: Option<CoreDataSourcesUpdateError> =
4729            serde_json::from_str(&local_var_content).ok();
4730        let local_var_error = ResponseContent {
4731            status: local_var_status,
4732            content: local_var_content,
4733            entity: local_var_entity,
4734        };
4735        Err(Error::ResponseError(local_var_error))
4736    }
4737}
4738
4739/// Retrieve a list of job results
4740pub async fn core_jobs_list(
4741    configuration: &configuration::Configuration,
4742    completed: Option<String>,
4743    completed__after: Option<String>,
4744    completed__before: Option<String>,
4745    created: Option<String>,
4746    created__after: Option<String>,
4747    created__before: Option<String>,
4748    id: Option<Vec<i32>>,
4749    id__empty: Option<bool>,
4750    id__gt: Option<Vec<i32>>,
4751    id__gte: Option<Vec<i32>>,
4752    id__lt: Option<Vec<i32>>,
4753    id__lte: Option<Vec<i32>>,
4754    id__n: Option<Vec<i32>>,
4755    interval: Option<Vec<i32>>,
4756    interval__empty: Option<bool>,
4757    interval__gt: Option<Vec<i32>>,
4758    interval__gte: Option<Vec<i32>>,
4759    interval__lt: Option<Vec<i32>>,
4760    interval__lte: Option<Vec<i32>>,
4761    interval__n: Option<Vec<i32>>,
4762    job_id: Option<&str>,
4763    limit: Option<i32>,
4764    name: Option<Vec<String>>,
4765    name__empty: Option<bool>,
4766    name__ic: Option<Vec<String>>,
4767    name__ie: Option<Vec<String>>,
4768    name__iew: Option<Vec<String>>,
4769    name__iregex: Option<Vec<String>>,
4770    name__isw: Option<Vec<String>>,
4771    name__n: Option<Vec<String>>,
4772    name__nic: Option<Vec<String>>,
4773    name__nie: Option<Vec<String>>,
4774    name__niew: Option<Vec<String>>,
4775    name__nisw: Option<Vec<String>>,
4776    name__regex: Option<Vec<String>>,
4777    object_id: Option<Vec<i32>>,
4778    object_id__empty: Option<bool>,
4779    object_id__gt: Option<Vec<i32>>,
4780    object_id__gte: Option<Vec<i32>>,
4781    object_id__lt: Option<Vec<i32>>,
4782    object_id__lte: Option<Vec<i32>>,
4783    object_id__n: Option<Vec<i32>>,
4784    object_type: Option<Vec<String>>,
4785    object_type__n: Option<Vec<String>>,
4786    object_type_id: Option<Vec<i32>>,
4787    object_type_id__n: Option<Vec<i32>>,
4788    offset: Option<i32>,
4789    ordering: Option<&str>,
4790    q: Option<&str>,
4791    queue_name: Option<&str>,
4792    queue_name__empty: Option<bool>,
4793    queue_name__ic: Option<&str>,
4794    queue_name__ie: Option<&str>,
4795    queue_name__iew: Option<&str>,
4796    queue_name__iregex: Option<&str>,
4797    queue_name__isw: Option<&str>,
4798    queue_name__n: Option<&str>,
4799    queue_name__nic: Option<&str>,
4800    queue_name__nie: Option<&str>,
4801    queue_name__niew: Option<&str>,
4802    queue_name__nisw: Option<&str>,
4803    queue_name__regex: Option<&str>,
4804    scheduled: Option<String>,
4805    scheduled__after: Option<String>,
4806    scheduled__before: Option<String>,
4807    started: Option<String>,
4808    started__after: Option<String>,
4809    started__before: Option<String>,
4810    status: Option<Vec<String>>,
4811    status__empty: Option<bool>,
4812    status__ic: Option<Vec<String>>,
4813    status__ie: Option<Vec<String>>,
4814    status__iew: Option<Vec<String>>,
4815    status__iregex: Option<Vec<String>>,
4816    status__isw: Option<Vec<String>>,
4817    status__n: Option<Vec<String>>,
4818    status__nic: Option<Vec<String>>,
4819    status__nie: Option<Vec<String>>,
4820    status__niew: Option<Vec<String>>,
4821    status__nisw: Option<Vec<String>>,
4822    status__regex: Option<Vec<String>>,
4823    user: Option<i32>,
4824    user__n: Option<i32>,
4825) -> Result<crate::models::PaginatedJobList, Error<CoreJobsListError>> {
4826    let local_var_configuration = configuration;
4827
4828    let local_var_client = &local_var_configuration.client;
4829
4830    let local_var_uri_str = format!("{}/api/core/jobs/", local_var_configuration.base_path);
4831    let mut local_var_req_builder =
4832        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4833
4834    if let Some(ref local_var_str) = completed {
4835        local_var_req_builder =
4836            local_var_req_builder.query(&[("completed", &local_var_str.to_string())]);
4837    }
4838    if let Some(ref local_var_str) = completed__after {
4839        local_var_req_builder =
4840            local_var_req_builder.query(&[("completed__after", &local_var_str.to_string())]);
4841    }
4842    if let Some(ref local_var_str) = completed__before {
4843        local_var_req_builder =
4844            local_var_req_builder.query(&[("completed__before", &local_var_str.to_string())]);
4845    }
4846    if let Some(ref local_var_str) = created {
4847        local_var_req_builder =
4848            local_var_req_builder.query(&[("created", &local_var_str.to_string())]);
4849    }
4850    if let Some(ref local_var_str) = created__after {
4851        local_var_req_builder =
4852            local_var_req_builder.query(&[("created__after", &local_var_str.to_string())]);
4853    }
4854    if let Some(ref local_var_str) = created__before {
4855        local_var_req_builder =
4856            local_var_req_builder.query(&[("created__before", &local_var_str.to_string())]);
4857    }
4858    if let Some(ref local_var_str) = id {
4859        local_var_req_builder = match "multi" {
4860            "multi" => local_var_req_builder.query(
4861                &local_var_str
4862                    .into_iter()
4863                    .map(|p| ("id".to_owned(), p.to_string()))
4864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4865            ),
4866            _ => local_var_req_builder.query(&[(
4867                "id",
4868                &local_var_str
4869                    .into_iter()
4870                    .map(|p| p.to_string())
4871                    .collect::<Vec<String>>()
4872                    .join(",")
4873                    .to_string(),
4874            )]),
4875        };
4876    }
4877    if let Some(ref local_var_str) = id__empty {
4878        local_var_req_builder =
4879            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4880    }
4881    if let Some(ref local_var_str) = id__gt {
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__gt".to_owned(), p.to_string()))
4887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4888            ),
4889            _ => local_var_req_builder.query(&[(
4890                "id__gt",
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) = id__gte {
4901        local_var_req_builder = match "multi" {
4902            "multi" => local_var_req_builder.query(
4903                &local_var_str
4904                    .into_iter()
4905                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4907            ),
4908            _ => local_var_req_builder.query(&[(
4909                "id__gte",
4910                &local_var_str
4911                    .into_iter()
4912                    .map(|p| p.to_string())
4913                    .collect::<Vec<String>>()
4914                    .join(",")
4915                    .to_string(),
4916            )]),
4917        };
4918    }
4919    if let Some(ref local_var_str) = id__lt {
4920        local_var_req_builder = match "multi" {
4921            "multi" => local_var_req_builder.query(
4922                &local_var_str
4923                    .into_iter()
4924                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4926            ),
4927            _ => local_var_req_builder.query(&[(
4928                "id__lt",
4929                &local_var_str
4930                    .into_iter()
4931                    .map(|p| p.to_string())
4932                    .collect::<Vec<String>>()
4933                    .join(",")
4934                    .to_string(),
4935            )]),
4936        };
4937    }
4938    if let Some(ref local_var_str) = id__lte {
4939        local_var_req_builder = match "multi" {
4940            "multi" => local_var_req_builder.query(
4941                &local_var_str
4942                    .into_iter()
4943                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4945            ),
4946            _ => local_var_req_builder.query(&[(
4947                "id__lte",
4948                &local_var_str
4949                    .into_iter()
4950                    .map(|p| p.to_string())
4951                    .collect::<Vec<String>>()
4952                    .join(",")
4953                    .to_string(),
4954            )]),
4955        };
4956    }
4957    if let Some(ref local_var_str) = id__n {
4958        local_var_req_builder = match "multi" {
4959            "multi" => local_var_req_builder.query(
4960                &local_var_str
4961                    .into_iter()
4962                    .map(|p| ("id__n".to_owned(), p.to_string()))
4963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4964            ),
4965            _ => local_var_req_builder.query(&[(
4966                "id__n",
4967                &local_var_str
4968                    .into_iter()
4969                    .map(|p| p.to_string())
4970                    .collect::<Vec<String>>()
4971                    .join(",")
4972                    .to_string(),
4973            )]),
4974        };
4975    }
4976    if let Some(ref local_var_str) = interval {
4977        local_var_req_builder = match "multi" {
4978            "multi" => local_var_req_builder.query(
4979                &local_var_str
4980                    .into_iter()
4981                    .map(|p| ("interval".to_owned(), p.to_string()))
4982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4983            ),
4984            _ => local_var_req_builder.query(&[(
4985                "interval",
4986                &local_var_str
4987                    .into_iter()
4988                    .map(|p| p.to_string())
4989                    .collect::<Vec<String>>()
4990                    .join(",")
4991                    .to_string(),
4992            )]),
4993        };
4994    }
4995    if let Some(ref local_var_str) = interval__empty {
4996        local_var_req_builder =
4997            local_var_req_builder.query(&[("interval__empty", &local_var_str.to_string())]);
4998    }
4999    if let Some(ref local_var_str) = interval__gt {
5000        local_var_req_builder = match "multi" {
5001            "multi" => local_var_req_builder.query(
5002                &local_var_str
5003                    .into_iter()
5004                    .map(|p| ("interval__gt".to_owned(), p.to_string()))
5005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5006            ),
5007            _ => local_var_req_builder.query(&[(
5008                "interval__gt",
5009                &local_var_str
5010                    .into_iter()
5011                    .map(|p| p.to_string())
5012                    .collect::<Vec<String>>()
5013                    .join(",")
5014                    .to_string(),
5015            )]),
5016        };
5017    }
5018    if let Some(ref local_var_str) = interval__gte {
5019        local_var_req_builder = match "multi" {
5020            "multi" => local_var_req_builder.query(
5021                &local_var_str
5022                    .into_iter()
5023                    .map(|p| ("interval__gte".to_owned(), p.to_string()))
5024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5025            ),
5026            _ => local_var_req_builder.query(&[(
5027                "interval__gte",
5028                &local_var_str
5029                    .into_iter()
5030                    .map(|p| p.to_string())
5031                    .collect::<Vec<String>>()
5032                    .join(",")
5033                    .to_string(),
5034            )]),
5035        };
5036    }
5037    if let Some(ref local_var_str) = interval__lt {
5038        local_var_req_builder = match "multi" {
5039            "multi" => local_var_req_builder.query(
5040                &local_var_str
5041                    .into_iter()
5042                    .map(|p| ("interval__lt".to_owned(), p.to_string()))
5043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5044            ),
5045            _ => local_var_req_builder.query(&[(
5046                "interval__lt",
5047                &local_var_str
5048                    .into_iter()
5049                    .map(|p| p.to_string())
5050                    .collect::<Vec<String>>()
5051                    .join(",")
5052                    .to_string(),
5053            )]),
5054        };
5055    }
5056    if let Some(ref local_var_str) = interval__lte {
5057        local_var_req_builder = match "multi" {
5058            "multi" => local_var_req_builder.query(
5059                &local_var_str
5060                    .into_iter()
5061                    .map(|p| ("interval__lte".to_owned(), p.to_string()))
5062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5063            ),
5064            _ => local_var_req_builder.query(&[(
5065                "interval__lte",
5066                &local_var_str
5067                    .into_iter()
5068                    .map(|p| p.to_string())
5069                    .collect::<Vec<String>>()
5070                    .join(",")
5071                    .to_string(),
5072            )]),
5073        };
5074    }
5075    if let Some(ref local_var_str) = interval__n {
5076        local_var_req_builder = match "multi" {
5077            "multi" => local_var_req_builder.query(
5078                &local_var_str
5079                    .into_iter()
5080                    .map(|p| ("interval__n".to_owned(), p.to_string()))
5081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5082            ),
5083            _ => local_var_req_builder.query(&[(
5084                "interval__n",
5085                &local_var_str
5086                    .into_iter()
5087                    .map(|p| p.to_string())
5088                    .collect::<Vec<String>>()
5089                    .join(",")
5090                    .to_string(),
5091            )]),
5092        };
5093    }
5094    if let Some(ref local_var_str) = job_id {
5095        local_var_req_builder =
5096            local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
5097    }
5098    if let Some(ref local_var_str) = limit {
5099        local_var_req_builder =
5100            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5101    }
5102    if let Some(ref local_var_str) = name {
5103        local_var_req_builder = match "multi" {
5104            "multi" => local_var_req_builder.query(
5105                &local_var_str
5106                    .into_iter()
5107                    .map(|p| ("name".to_owned(), p.to_string()))
5108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5109            ),
5110            _ => local_var_req_builder.query(&[(
5111                "name",
5112                &local_var_str
5113                    .into_iter()
5114                    .map(|p| p.to_string())
5115                    .collect::<Vec<String>>()
5116                    .join(",")
5117                    .to_string(),
5118            )]),
5119        };
5120    }
5121    if let Some(ref local_var_str) = name__empty {
5122        local_var_req_builder =
5123            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5124    }
5125    if let Some(ref local_var_str) = name__ic {
5126        local_var_req_builder = match "multi" {
5127            "multi" => local_var_req_builder.query(
5128                &local_var_str
5129                    .into_iter()
5130                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5132            ),
5133            _ => local_var_req_builder.query(&[(
5134                "name__ic",
5135                &local_var_str
5136                    .into_iter()
5137                    .map(|p| p.to_string())
5138                    .collect::<Vec<String>>()
5139                    .join(",")
5140                    .to_string(),
5141            )]),
5142        };
5143    }
5144    if let Some(ref local_var_str) = name__ie {
5145        local_var_req_builder = match "multi" {
5146            "multi" => local_var_req_builder.query(
5147                &local_var_str
5148                    .into_iter()
5149                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5151            ),
5152            _ => local_var_req_builder.query(&[(
5153                "name__ie",
5154                &local_var_str
5155                    .into_iter()
5156                    .map(|p| p.to_string())
5157                    .collect::<Vec<String>>()
5158                    .join(",")
5159                    .to_string(),
5160            )]),
5161        };
5162    }
5163    if let Some(ref local_var_str) = name__iew {
5164        local_var_req_builder = match "multi" {
5165            "multi" => local_var_req_builder.query(
5166                &local_var_str
5167                    .into_iter()
5168                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5170            ),
5171            _ => local_var_req_builder.query(&[(
5172                "name__iew",
5173                &local_var_str
5174                    .into_iter()
5175                    .map(|p| p.to_string())
5176                    .collect::<Vec<String>>()
5177                    .join(",")
5178                    .to_string(),
5179            )]),
5180        };
5181    }
5182    if let Some(ref local_var_str) = name__iregex {
5183        local_var_req_builder = match "multi" {
5184            "multi" => local_var_req_builder.query(
5185                &local_var_str
5186                    .into_iter()
5187                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5189            ),
5190            _ => local_var_req_builder.query(&[(
5191                "name__iregex",
5192                &local_var_str
5193                    .into_iter()
5194                    .map(|p| p.to_string())
5195                    .collect::<Vec<String>>()
5196                    .join(",")
5197                    .to_string(),
5198            )]),
5199        };
5200    }
5201    if let Some(ref local_var_str) = name__isw {
5202        local_var_req_builder = match "multi" {
5203            "multi" => local_var_req_builder.query(
5204                &local_var_str
5205                    .into_iter()
5206                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5208            ),
5209            _ => local_var_req_builder.query(&[(
5210                "name__isw",
5211                &local_var_str
5212                    .into_iter()
5213                    .map(|p| p.to_string())
5214                    .collect::<Vec<String>>()
5215                    .join(",")
5216                    .to_string(),
5217            )]),
5218        };
5219    }
5220    if let Some(ref local_var_str) = name__n {
5221        local_var_req_builder = match "multi" {
5222            "multi" => local_var_req_builder.query(
5223                &local_var_str
5224                    .into_iter()
5225                    .map(|p| ("name__n".to_owned(), p.to_string()))
5226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5227            ),
5228            _ => local_var_req_builder.query(&[(
5229                "name__n",
5230                &local_var_str
5231                    .into_iter()
5232                    .map(|p| p.to_string())
5233                    .collect::<Vec<String>>()
5234                    .join(",")
5235                    .to_string(),
5236            )]),
5237        };
5238    }
5239    if let Some(ref local_var_str) = name__nic {
5240        local_var_req_builder = match "multi" {
5241            "multi" => local_var_req_builder.query(
5242                &local_var_str
5243                    .into_iter()
5244                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5246            ),
5247            _ => local_var_req_builder.query(&[(
5248                "name__nic",
5249                &local_var_str
5250                    .into_iter()
5251                    .map(|p| p.to_string())
5252                    .collect::<Vec<String>>()
5253                    .join(",")
5254                    .to_string(),
5255            )]),
5256        };
5257    }
5258    if let Some(ref local_var_str) = name__nie {
5259        local_var_req_builder = match "multi" {
5260            "multi" => local_var_req_builder.query(
5261                &local_var_str
5262                    .into_iter()
5263                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5265            ),
5266            _ => local_var_req_builder.query(&[(
5267                "name__nie",
5268                &local_var_str
5269                    .into_iter()
5270                    .map(|p| p.to_string())
5271                    .collect::<Vec<String>>()
5272                    .join(",")
5273                    .to_string(),
5274            )]),
5275        };
5276    }
5277    if let Some(ref local_var_str) = name__niew {
5278        local_var_req_builder = match "multi" {
5279            "multi" => local_var_req_builder.query(
5280                &local_var_str
5281                    .into_iter()
5282                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5284            ),
5285            _ => local_var_req_builder.query(&[(
5286                "name__niew",
5287                &local_var_str
5288                    .into_iter()
5289                    .map(|p| p.to_string())
5290                    .collect::<Vec<String>>()
5291                    .join(",")
5292                    .to_string(),
5293            )]),
5294        };
5295    }
5296    if let Some(ref local_var_str) = name__nisw {
5297        local_var_req_builder = match "multi" {
5298            "multi" => local_var_req_builder.query(
5299                &local_var_str
5300                    .into_iter()
5301                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5303            ),
5304            _ => local_var_req_builder.query(&[(
5305                "name__nisw",
5306                &local_var_str
5307                    .into_iter()
5308                    .map(|p| p.to_string())
5309                    .collect::<Vec<String>>()
5310                    .join(",")
5311                    .to_string(),
5312            )]),
5313        };
5314    }
5315    if let Some(ref local_var_str) = name__regex {
5316        local_var_req_builder = match "multi" {
5317            "multi" => local_var_req_builder.query(
5318                &local_var_str
5319                    .into_iter()
5320                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5322            ),
5323            _ => local_var_req_builder.query(&[(
5324                "name__regex",
5325                &local_var_str
5326                    .into_iter()
5327                    .map(|p| p.to_string())
5328                    .collect::<Vec<String>>()
5329                    .join(",")
5330                    .to_string(),
5331            )]),
5332        };
5333    }
5334    if let Some(ref local_var_str) = object_id {
5335        local_var_req_builder = match "multi" {
5336            "multi" => local_var_req_builder.query(
5337                &local_var_str
5338                    .into_iter()
5339                    .map(|p| ("object_id".to_owned(), p.to_string()))
5340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5341            ),
5342            _ => local_var_req_builder.query(&[(
5343                "object_id",
5344                &local_var_str
5345                    .into_iter()
5346                    .map(|p| p.to_string())
5347                    .collect::<Vec<String>>()
5348                    .join(",")
5349                    .to_string(),
5350            )]),
5351        };
5352    }
5353    if let Some(ref local_var_str) = object_id__empty {
5354        local_var_req_builder =
5355            local_var_req_builder.query(&[("object_id__empty", &local_var_str.to_string())]);
5356    }
5357    if let Some(ref local_var_str) = object_id__gt {
5358        local_var_req_builder = match "multi" {
5359            "multi" => local_var_req_builder.query(
5360                &local_var_str
5361                    .into_iter()
5362                    .map(|p| ("object_id__gt".to_owned(), p.to_string()))
5363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5364            ),
5365            _ => local_var_req_builder.query(&[(
5366                "object_id__gt",
5367                &local_var_str
5368                    .into_iter()
5369                    .map(|p| p.to_string())
5370                    .collect::<Vec<String>>()
5371                    .join(",")
5372                    .to_string(),
5373            )]),
5374        };
5375    }
5376    if let Some(ref local_var_str) = object_id__gte {
5377        local_var_req_builder = match "multi" {
5378            "multi" => local_var_req_builder.query(
5379                &local_var_str
5380                    .into_iter()
5381                    .map(|p| ("object_id__gte".to_owned(), p.to_string()))
5382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5383            ),
5384            _ => local_var_req_builder.query(&[(
5385                "object_id__gte",
5386                &local_var_str
5387                    .into_iter()
5388                    .map(|p| p.to_string())
5389                    .collect::<Vec<String>>()
5390                    .join(",")
5391                    .to_string(),
5392            )]),
5393        };
5394    }
5395    if let Some(ref local_var_str) = object_id__lt {
5396        local_var_req_builder = match "multi" {
5397            "multi" => local_var_req_builder.query(
5398                &local_var_str
5399                    .into_iter()
5400                    .map(|p| ("object_id__lt".to_owned(), p.to_string()))
5401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5402            ),
5403            _ => local_var_req_builder.query(&[(
5404                "object_id__lt",
5405                &local_var_str
5406                    .into_iter()
5407                    .map(|p| p.to_string())
5408                    .collect::<Vec<String>>()
5409                    .join(",")
5410                    .to_string(),
5411            )]),
5412        };
5413    }
5414    if let Some(ref local_var_str) = object_id__lte {
5415        local_var_req_builder = match "multi" {
5416            "multi" => local_var_req_builder.query(
5417                &local_var_str
5418                    .into_iter()
5419                    .map(|p| ("object_id__lte".to_owned(), p.to_string()))
5420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5421            ),
5422            _ => local_var_req_builder.query(&[(
5423                "object_id__lte",
5424                &local_var_str
5425                    .into_iter()
5426                    .map(|p| p.to_string())
5427                    .collect::<Vec<String>>()
5428                    .join(",")
5429                    .to_string(),
5430            )]),
5431        };
5432    }
5433    if let Some(ref local_var_str) = object_id__n {
5434        local_var_req_builder = match "multi" {
5435            "multi" => local_var_req_builder.query(
5436                &local_var_str
5437                    .into_iter()
5438                    .map(|p| ("object_id__n".to_owned(), p.to_string()))
5439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5440            ),
5441            _ => local_var_req_builder.query(&[(
5442                "object_id__n",
5443                &local_var_str
5444                    .into_iter()
5445                    .map(|p| p.to_string())
5446                    .collect::<Vec<String>>()
5447                    .join(",")
5448                    .to_string(),
5449            )]),
5450        };
5451    }
5452    if let Some(ref local_var_str) = object_type {
5453        local_var_req_builder = match "multi" {
5454            "multi" => local_var_req_builder.query(
5455                &local_var_str
5456                    .into_iter()
5457                    .map(|p| ("object_type".to_owned(), p.to_string()))
5458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5459            ),
5460            _ => local_var_req_builder.query(&[(
5461                "object_type",
5462                &local_var_str
5463                    .into_iter()
5464                    .map(|p| p.to_string())
5465                    .collect::<Vec<String>>()
5466                    .join(",")
5467                    .to_string(),
5468            )]),
5469        };
5470    }
5471    if let Some(ref local_var_str) = object_type__n {
5472        local_var_req_builder = match "multi" {
5473            "multi" => local_var_req_builder.query(
5474                &local_var_str
5475                    .into_iter()
5476                    .map(|p| ("object_type__n".to_owned(), p.to_string()))
5477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5478            ),
5479            _ => local_var_req_builder.query(&[(
5480                "object_type__n",
5481                &local_var_str
5482                    .into_iter()
5483                    .map(|p| p.to_string())
5484                    .collect::<Vec<String>>()
5485                    .join(",")
5486                    .to_string(),
5487            )]),
5488        };
5489    }
5490    if let Some(ref local_var_str) = object_type_id {
5491        local_var_req_builder = match "multi" {
5492            "multi" => local_var_req_builder.query(
5493                &local_var_str
5494                    .into_iter()
5495                    .map(|p| ("object_type_id".to_owned(), p.to_string()))
5496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5497            ),
5498            _ => local_var_req_builder.query(&[(
5499                "object_type_id",
5500                &local_var_str
5501                    .into_iter()
5502                    .map(|p| p.to_string())
5503                    .collect::<Vec<String>>()
5504                    .join(",")
5505                    .to_string(),
5506            )]),
5507        };
5508    }
5509    if let Some(ref local_var_str) = object_type_id__n {
5510        local_var_req_builder = match "multi" {
5511            "multi" => local_var_req_builder.query(
5512                &local_var_str
5513                    .into_iter()
5514                    .map(|p| ("object_type_id__n".to_owned(), p.to_string()))
5515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5516            ),
5517            _ => local_var_req_builder.query(&[(
5518                "object_type_id__n",
5519                &local_var_str
5520                    .into_iter()
5521                    .map(|p| p.to_string())
5522                    .collect::<Vec<String>>()
5523                    .join(",")
5524                    .to_string(),
5525            )]),
5526        };
5527    }
5528    if let Some(ref local_var_str) = offset {
5529        local_var_req_builder =
5530            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5531    }
5532    if let Some(ref local_var_str) = ordering {
5533        local_var_req_builder =
5534            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5535    }
5536    if let Some(ref local_var_str) = q {
5537        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5538    }
5539    if let Some(ref local_var_str) = queue_name {
5540        local_var_req_builder =
5541            local_var_req_builder.query(&[("queue_name", &local_var_str.to_string())]);
5542    }
5543    if let Some(ref local_var_str) = queue_name__empty {
5544        local_var_req_builder =
5545            local_var_req_builder.query(&[("queue_name__empty", &local_var_str.to_string())]);
5546    }
5547    if let Some(ref local_var_str) = queue_name__ic {
5548        local_var_req_builder =
5549            local_var_req_builder.query(&[("queue_name__ic", &local_var_str.to_string())]);
5550    }
5551    if let Some(ref local_var_str) = queue_name__ie {
5552        local_var_req_builder =
5553            local_var_req_builder.query(&[("queue_name__ie", &local_var_str.to_string())]);
5554    }
5555    if let Some(ref local_var_str) = queue_name__iew {
5556        local_var_req_builder =
5557            local_var_req_builder.query(&[("queue_name__iew", &local_var_str.to_string())]);
5558    }
5559    if let Some(ref local_var_str) = queue_name__iregex {
5560        local_var_req_builder =
5561            local_var_req_builder.query(&[("queue_name__iregex", &local_var_str.to_string())]);
5562    }
5563    if let Some(ref local_var_str) = queue_name__isw {
5564        local_var_req_builder =
5565            local_var_req_builder.query(&[("queue_name__isw", &local_var_str.to_string())]);
5566    }
5567    if let Some(ref local_var_str) = queue_name__n {
5568        local_var_req_builder =
5569            local_var_req_builder.query(&[("queue_name__n", &local_var_str.to_string())]);
5570    }
5571    if let Some(ref local_var_str) = queue_name__nic {
5572        local_var_req_builder =
5573            local_var_req_builder.query(&[("queue_name__nic", &local_var_str.to_string())]);
5574    }
5575    if let Some(ref local_var_str) = queue_name__nie {
5576        local_var_req_builder =
5577            local_var_req_builder.query(&[("queue_name__nie", &local_var_str.to_string())]);
5578    }
5579    if let Some(ref local_var_str) = queue_name__niew {
5580        local_var_req_builder =
5581            local_var_req_builder.query(&[("queue_name__niew", &local_var_str.to_string())]);
5582    }
5583    if let Some(ref local_var_str) = queue_name__nisw {
5584        local_var_req_builder =
5585            local_var_req_builder.query(&[("queue_name__nisw", &local_var_str.to_string())]);
5586    }
5587    if let Some(ref local_var_str) = queue_name__regex {
5588        local_var_req_builder =
5589            local_var_req_builder.query(&[("queue_name__regex", &local_var_str.to_string())]);
5590    }
5591    if let Some(ref local_var_str) = scheduled {
5592        local_var_req_builder =
5593            local_var_req_builder.query(&[("scheduled", &local_var_str.to_string())]);
5594    }
5595    if let Some(ref local_var_str) = scheduled__after {
5596        local_var_req_builder =
5597            local_var_req_builder.query(&[("scheduled__after", &local_var_str.to_string())]);
5598    }
5599    if let Some(ref local_var_str) = scheduled__before {
5600        local_var_req_builder =
5601            local_var_req_builder.query(&[("scheduled__before", &local_var_str.to_string())]);
5602    }
5603    if let Some(ref local_var_str) = started {
5604        local_var_req_builder =
5605            local_var_req_builder.query(&[("started", &local_var_str.to_string())]);
5606    }
5607    if let Some(ref local_var_str) = started__after {
5608        local_var_req_builder =
5609            local_var_req_builder.query(&[("started__after", &local_var_str.to_string())]);
5610    }
5611    if let Some(ref local_var_str) = started__before {
5612        local_var_req_builder =
5613            local_var_req_builder.query(&[("started__before", &local_var_str.to_string())]);
5614    }
5615    if let Some(ref local_var_str) = status {
5616        local_var_req_builder = match "multi" {
5617            "multi" => local_var_req_builder.query(
5618                &local_var_str
5619                    .into_iter()
5620                    .map(|p| ("status".to_owned(), p.to_string()))
5621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5622            ),
5623            _ => local_var_req_builder.query(&[(
5624                "status",
5625                &local_var_str
5626                    .into_iter()
5627                    .map(|p| p.to_string())
5628                    .collect::<Vec<String>>()
5629                    .join(",")
5630                    .to_string(),
5631            )]),
5632        };
5633    }
5634    if let Some(ref local_var_str) = status__empty {
5635        local_var_req_builder =
5636            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
5637    }
5638    if let Some(ref local_var_str) = status__ic {
5639        local_var_req_builder = match "multi" {
5640            "multi" => local_var_req_builder.query(
5641                &local_var_str
5642                    .into_iter()
5643                    .map(|p| ("status__ic".to_owned(), p.to_string()))
5644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5645            ),
5646            _ => local_var_req_builder.query(&[(
5647                "status__ic",
5648                &local_var_str
5649                    .into_iter()
5650                    .map(|p| p.to_string())
5651                    .collect::<Vec<String>>()
5652                    .join(",")
5653                    .to_string(),
5654            )]),
5655        };
5656    }
5657    if let Some(ref local_var_str) = status__ie {
5658        local_var_req_builder = match "multi" {
5659            "multi" => local_var_req_builder.query(
5660                &local_var_str
5661                    .into_iter()
5662                    .map(|p| ("status__ie".to_owned(), p.to_string()))
5663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5664            ),
5665            _ => local_var_req_builder.query(&[(
5666                "status__ie",
5667                &local_var_str
5668                    .into_iter()
5669                    .map(|p| p.to_string())
5670                    .collect::<Vec<String>>()
5671                    .join(",")
5672                    .to_string(),
5673            )]),
5674        };
5675    }
5676    if let Some(ref local_var_str) = status__iew {
5677        local_var_req_builder = match "multi" {
5678            "multi" => local_var_req_builder.query(
5679                &local_var_str
5680                    .into_iter()
5681                    .map(|p| ("status__iew".to_owned(), p.to_string()))
5682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5683            ),
5684            _ => local_var_req_builder.query(&[(
5685                "status__iew",
5686                &local_var_str
5687                    .into_iter()
5688                    .map(|p| p.to_string())
5689                    .collect::<Vec<String>>()
5690                    .join(",")
5691                    .to_string(),
5692            )]),
5693        };
5694    }
5695    if let Some(ref local_var_str) = status__iregex {
5696        local_var_req_builder = match "multi" {
5697            "multi" => local_var_req_builder.query(
5698                &local_var_str
5699                    .into_iter()
5700                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
5701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5702            ),
5703            _ => local_var_req_builder.query(&[(
5704                "status__iregex",
5705                &local_var_str
5706                    .into_iter()
5707                    .map(|p| p.to_string())
5708                    .collect::<Vec<String>>()
5709                    .join(",")
5710                    .to_string(),
5711            )]),
5712        };
5713    }
5714    if let Some(ref local_var_str) = status__isw {
5715        local_var_req_builder = match "multi" {
5716            "multi" => local_var_req_builder.query(
5717                &local_var_str
5718                    .into_iter()
5719                    .map(|p| ("status__isw".to_owned(), p.to_string()))
5720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5721            ),
5722            _ => local_var_req_builder.query(&[(
5723                "status__isw",
5724                &local_var_str
5725                    .into_iter()
5726                    .map(|p| p.to_string())
5727                    .collect::<Vec<String>>()
5728                    .join(",")
5729                    .to_string(),
5730            )]),
5731        };
5732    }
5733    if let Some(ref local_var_str) = status__n {
5734        local_var_req_builder = match "multi" {
5735            "multi" => local_var_req_builder.query(
5736                &local_var_str
5737                    .into_iter()
5738                    .map(|p| ("status__n".to_owned(), p.to_string()))
5739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5740            ),
5741            _ => local_var_req_builder.query(&[(
5742                "status__n",
5743                &local_var_str
5744                    .into_iter()
5745                    .map(|p| p.to_string())
5746                    .collect::<Vec<String>>()
5747                    .join(",")
5748                    .to_string(),
5749            )]),
5750        };
5751    }
5752    if let Some(ref local_var_str) = status__nic {
5753        local_var_req_builder = match "multi" {
5754            "multi" => local_var_req_builder.query(
5755                &local_var_str
5756                    .into_iter()
5757                    .map(|p| ("status__nic".to_owned(), p.to_string()))
5758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5759            ),
5760            _ => local_var_req_builder.query(&[(
5761                "status__nic",
5762                &local_var_str
5763                    .into_iter()
5764                    .map(|p| p.to_string())
5765                    .collect::<Vec<String>>()
5766                    .join(",")
5767                    .to_string(),
5768            )]),
5769        };
5770    }
5771    if let Some(ref local_var_str) = status__nie {
5772        local_var_req_builder = match "multi" {
5773            "multi" => local_var_req_builder.query(
5774                &local_var_str
5775                    .into_iter()
5776                    .map(|p| ("status__nie".to_owned(), p.to_string()))
5777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5778            ),
5779            _ => local_var_req_builder.query(&[(
5780                "status__nie",
5781                &local_var_str
5782                    .into_iter()
5783                    .map(|p| p.to_string())
5784                    .collect::<Vec<String>>()
5785                    .join(",")
5786                    .to_string(),
5787            )]),
5788        };
5789    }
5790    if let Some(ref local_var_str) = status__niew {
5791        local_var_req_builder = match "multi" {
5792            "multi" => local_var_req_builder.query(
5793                &local_var_str
5794                    .into_iter()
5795                    .map(|p| ("status__niew".to_owned(), p.to_string()))
5796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5797            ),
5798            _ => local_var_req_builder.query(&[(
5799                "status__niew",
5800                &local_var_str
5801                    .into_iter()
5802                    .map(|p| p.to_string())
5803                    .collect::<Vec<String>>()
5804                    .join(",")
5805                    .to_string(),
5806            )]),
5807        };
5808    }
5809    if let Some(ref local_var_str) = status__nisw {
5810        local_var_req_builder = match "multi" {
5811            "multi" => local_var_req_builder.query(
5812                &local_var_str
5813                    .into_iter()
5814                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
5815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5816            ),
5817            _ => local_var_req_builder.query(&[(
5818                "status__nisw",
5819                &local_var_str
5820                    .into_iter()
5821                    .map(|p| p.to_string())
5822                    .collect::<Vec<String>>()
5823                    .join(",")
5824                    .to_string(),
5825            )]),
5826        };
5827    }
5828    if let Some(ref local_var_str) = status__regex {
5829        local_var_req_builder = match "multi" {
5830            "multi" => local_var_req_builder.query(
5831                &local_var_str
5832                    .into_iter()
5833                    .map(|p| ("status__regex".to_owned(), p.to_string()))
5834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5835            ),
5836            _ => local_var_req_builder.query(&[(
5837                "status__regex",
5838                &local_var_str
5839                    .into_iter()
5840                    .map(|p| p.to_string())
5841                    .collect::<Vec<String>>()
5842                    .join(",")
5843                    .to_string(),
5844            )]),
5845        };
5846    }
5847    if let Some(ref local_var_str) = user {
5848        local_var_req_builder =
5849            local_var_req_builder.query(&[("user", &local_var_str.to_string())]);
5850    }
5851    if let Some(ref local_var_str) = user__n {
5852        local_var_req_builder =
5853            local_var_req_builder.query(&[("user__n", &local_var_str.to_string())]);
5854    }
5855    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5856        local_var_req_builder =
5857            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5858    }
5859    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5860        let local_var_key = local_var_apikey.key.clone();
5861        let local_var_value = match local_var_apikey.prefix {
5862            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5863            None => local_var_key,
5864        };
5865        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5866    };
5867
5868    let local_var_req = local_var_req_builder.build()?;
5869    let local_var_resp = local_var_client.execute(local_var_req).await?;
5870
5871    let local_var_status = local_var_resp.status();
5872    let local_var_content = local_var_resp.text().await?;
5873
5874    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5875        serde_json::from_str(&local_var_content).map_err(Error::from)
5876    } else {
5877        let local_var_entity: Option<CoreJobsListError> =
5878            serde_json::from_str(&local_var_content).ok();
5879        let local_var_error = ResponseContent {
5880            status: local_var_status,
5881            content: local_var_content,
5882            entity: local_var_entity,
5883        };
5884        Err(Error::ResponseError(local_var_error))
5885    }
5886}
5887
5888/// Retrieve a list of job results
5889pub async fn core_jobs_retrieve(
5890    configuration: &configuration::Configuration,
5891    id: i32,
5892) -> Result<crate::models::Job, Error<CoreJobsRetrieveError>> {
5893    let local_var_configuration = configuration;
5894
5895    let local_var_client = &local_var_configuration.client;
5896
5897    let local_var_uri_str = format!(
5898        "{}/api/core/jobs/{id}/",
5899        local_var_configuration.base_path,
5900        id = id
5901    );
5902    let mut local_var_req_builder =
5903        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5904
5905    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5906        local_var_req_builder =
5907            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5908    }
5909    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5910        let local_var_key = local_var_apikey.key.clone();
5911        let local_var_value = match local_var_apikey.prefix {
5912            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5913            None => local_var_key,
5914        };
5915        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5916    };
5917
5918    let local_var_req = local_var_req_builder.build()?;
5919    let local_var_resp = local_var_client.execute(local_var_req).await?;
5920
5921    let local_var_status = local_var_resp.status();
5922    let local_var_content = local_var_resp.text().await?;
5923
5924    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5925        serde_json::from_str(&local_var_content).map_err(Error::from)
5926    } else {
5927        let local_var_entity: Option<CoreJobsRetrieveError> =
5928            serde_json::from_str(&local_var_content).ok();
5929        let local_var_error = ResponseContent {
5930            status: local_var_status,
5931            content: local_var_content,
5932            entity: local_var_entity,
5933        };
5934        Err(Error::ResponseError(local_var_error))
5935    }
5936}
5937
5938/// Retrieve a list of recent changes.
5939pub async fn core_object_changes_list(
5940    configuration: &configuration::Configuration,
5941    action: Option<&str>,
5942    action__empty: Option<bool>,
5943    action__ic: Option<Vec<String>>,
5944    action__ie: Option<Vec<String>>,
5945    action__iew: Option<Vec<String>>,
5946    action__iregex: Option<Vec<String>>,
5947    action__isw: Option<Vec<String>>,
5948    action__n: Option<&str>,
5949    action__nic: Option<Vec<String>>,
5950    action__nie: Option<Vec<String>>,
5951    action__niew: Option<Vec<String>>,
5952    action__nisw: Option<Vec<String>>,
5953    action__regex: Option<Vec<String>>,
5954    changed_object_id: Option<Vec<i32>>,
5955    changed_object_id__empty: Option<bool>,
5956    changed_object_id__gt: Option<Vec<i32>>,
5957    changed_object_id__gte: Option<Vec<i32>>,
5958    changed_object_id__lt: Option<Vec<i32>>,
5959    changed_object_id__lte: Option<Vec<i32>>,
5960    changed_object_id__n: Option<Vec<i32>>,
5961    changed_object_type: Option<Vec<String>>,
5962    changed_object_type__n: Option<Vec<String>>,
5963    changed_object_type_id: Option<Vec<i32>>,
5964    changed_object_type_id__n: Option<Vec<i32>>,
5965    id: Option<Vec<i32>>,
5966    id__empty: Option<bool>,
5967    id__gt: Option<Vec<i32>>,
5968    id__gte: Option<Vec<i32>>,
5969    id__lt: Option<Vec<i32>>,
5970    id__lte: Option<Vec<i32>>,
5971    id__n: Option<Vec<i32>>,
5972    limit: Option<i32>,
5973    object_repr: Option<Vec<String>>,
5974    object_repr__empty: Option<bool>,
5975    object_repr__ic: Option<Vec<String>>,
5976    object_repr__ie: Option<Vec<String>>,
5977    object_repr__iew: Option<Vec<String>>,
5978    object_repr__iregex: Option<Vec<String>>,
5979    object_repr__isw: Option<Vec<String>>,
5980    object_repr__n: Option<Vec<String>>,
5981    object_repr__nic: Option<Vec<String>>,
5982    object_repr__nie: Option<Vec<String>>,
5983    object_repr__niew: Option<Vec<String>>,
5984    object_repr__nisw: Option<Vec<String>>,
5985    object_repr__regex: Option<Vec<String>>,
5986    offset: Option<i32>,
5987    ordering: Option<&str>,
5988    q: Option<&str>,
5989    related_object_id: Option<Vec<i32>>,
5990    related_object_id__empty: Option<bool>,
5991    related_object_id__gt: Option<Vec<i32>>,
5992    related_object_id__gte: Option<Vec<i32>>,
5993    related_object_id__lt: Option<Vec<i32>>,
5994    related_object_id__lte: Option<Vec<i32>>,
5995    related_object_id__n: Option<Vec<i32>>,
5996    related_object_type: Option<Vec<String>>,
5997    related_object_type__n: Option<Vec<String>>,
5998    request_id: Option<&str>,
5999    time_after: Option<String>,
6000    time_before: Option<String>,
6001    user: Option<Vec<String>>,
6002    user__n: Option<Vec<String>>,
6003    user_id: Option<Vec<i32>>,
6004    user_id__n: Option<Vec<i32>>,
6005    user_name: Option<Vec<String>>,
6006    user_name__empty: Option<bool>,
6007    user_name__ic: Option<Vec<String>>,
6008    user_name__ie: Option<Vec<String>>,
6009    user_name__iew: Option<Vec<String>>,
6010    user_name__iregex: Option<Vec<String>>,
6011    user_name__isw: Option<Vec<String>>,
6012    user_name__n: Option<Vec<String>>,
6013    user_name__nic: Option<Vec<String>>,
6014    user_name__nie: Option<Vec<String>>,
6015    user_name__niew: Option<Vec<String>>,
6016    user_name__nisw: Option<Vec<String>>,
6017    user_name__regex: Option<Vec<String>>,
6018) -> Result<crate::models::PaginatedObjectChangeList, Error<CoreObjectChangesListError>> {
6019    let local_var_configuration = configuration;
6020
6021    let local_var_client = &local_var_configuration.client;
6022
6023    let local_var_uri_str = format!(
6024        "{}/api/core/object-changes/",
6025        local_var_configuration.base_path
6026    );
6027    let mut local_var_req_builder =
6028        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6029
6030    if let Some(ref local_var_str) = action {
6031        local_var_req_builder =
6032            local_var_req_builder.query(&[("action", &local_var_str.to_string())]);
6033    }
6034    if let Some(ref local_var_str) = action__empty {
6035        local_var_req_builder =
6036            local_var_req_builder.query(&[("action__empty", &local_var_str.to_string())]);
6037    }
6038    if let Some(ref local_var_str) = action__ic {
6039        local_var_req_builder = match "multi" {
6040            "multi" => local_var_req_builder.query(
6041                &local_var_str
6042                    .into_iter()
6043                    .map(|p| ("action__ic".to_owned(), p.to_string()))
6044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6045            ),
6046            _ => local_var_req_builder.query(&[(
6047                "action__ic",
6048                &local_var_str
6049                    .into_iter()
6050                    .map(|p| p.to_string())
6051                    .collect::<Vec<String>>()
6052                    .join(",")
6053                    .to_string(),
6054            )]),
6055        };
6056    }
6057    if let Some(ref local_var_str) = action__ie {
6058        local_var_req_builder = match "multi" {
6059            "multi" => local_var_req_builder.query(
6060                &local_var_str
6061                    .into_iter()
6062                    .map(|p| ("action__ie".to_owned(), p.to_string()))
6063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6064            ),
6065            _ => local_var_req_builder.query(&[(
6066                "action__ie",
6067                &local_var_str
6068                    .into_iter()
6069                    .map(|p| p.to_string())
6070                    .collect::<Vec<String>>()
6071                    .join(",")
6072                    .to_string(),
6073            )]),
6074        };
6075    }
6076    if let Some(ref local_var_str) = action__iew {
6077        local_var_req_builder = match "multi" {
6078            "multi" => local_var_req_builder.query(
6079                &local_var_str
6080                    .into_iter()
6081                    .map(|p| ("action__iew".to_owned(), p.to_string()))
6082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6083            ),
6084            _ => local_var_req_builder.query(&[(
6085                "action__iew",
6086                &local_var_str
6087                    .into_iter()
6088                    .map(|p| p.to_string())
6089                    .collect::<Vec<String>>()
6090                    .join(",")
6091                    .to_string(),
6092            )]),
6093        };
6094    }
6095    if let Some(ref local_var_str) = action__iregex {
6096        local_var_req_builder = match "multi" {
6097            "multi" => local_var_req_builder.query(
6098                &local_var_str
6099                    .into_iter()
6100                    .map(|p| ("action__iregex".to_owned(), p.to_string()))
6101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6102            ),
6103            _ => local_var_req_builder.query(&[(
6104                "action__iregex",
6105                &local_var_str
6106                    .into_iter()
6107                    .map(|p| p.to_string())
6108                    .collect::<Vec<String>>()
6109                    .join(",")
6110                    .to_string(),
6111            )]),
6112        };
6113    }
6114    if let Some(ref local_var_str) = action__isw {
6115        local_var_req_builder = match "multi" {
6116            "multi" => local_var_req_builder.query(
6117                &local_var_str
6118                    .into_iter()
6119                    .map(|p| ("action__isw".to_owned(), p.to_string()))
6120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6121            ),
6122            _ => local_var_req_builder.query(&[(
6123                "action__isw",
6124                &local_var_str
6125                    .into_iter()
6126                    .map(|p| p.to_string())
6127                    .collect::<Vec<String>>()
6128                    .join(",")
6129                    .to_string(),
6130            )]),
6131        };
6132    }
6133    if let Some(ref local_var_str) = action__n {
6134        local_var_req_builder =
6135            local_var_req_builder.query(&[("action__n", &local_var_str.to_string())]);
6136    }
6137    if let Some(ref local_var_str) = action__nic {
6138        local_var_req_builder = match "multi" {
6139            "multi" => local_var_req_builder.query(
6140                &local_var_str
6141                    .into_iter()
6142                    .map(|p| ("action__nic".to_owned(), p.to_string()))
6143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6144            ),
6145            _ => local_var_req_builder.query(&[(
6146                "action__nic",
6147                &local_var_str
6148                    .into_iter()
6149                    .map(|p| p.to_string())
6150                    .collect::<Vec<String>>()
6151                    .join(",")
6152                    .to_string(),
6153            )]),
6154        };
6155    }
6156    if let Some(ref local_var_str) = action__nie {
6157        local_var_req_builder = match "multi" {
6158            "multi" => local_var_req_builder.query(
6159                &local_var_str
6160                    .into_iter()
6161                    .map(|p| ("action__nie".to_owned(), p.to_string()))
6162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6163            ),
6164            _ => local_var_req_builder.query(&[(
6165                "action__nie",
6166                &local_var_str
6167                    .into_iter()
6168                    .map(|p| p.to_string())
6169                    .collect::<Vec<String>>()
6170                    .join(",")
6171                    .to_string(),
6172            )]),
6173        };
6174    }
6175    if let Some(ref local_var_str) = action__niew {
6176        local_var_req_builder = match "multi" {
6177            "multi" => local_var_req_builder.query(
6178                &local_var_str
6179                    .into_iter()
6180                    .map(|p| ("action__niew".to_owned(), p.to_string()))
6181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6182            ),
6183            _ => local_var_req_builder.query(&[(
6184                "action__niew",
6185                &local_var_str
6186                    .into_iter()
6187                    .map(|p| p.to_string())
6188                    .collect::<Vec<String>>()
6189                    .join(",")
6190                    .to_string(),
6191            )]),
6192        };
6193    }
6194    if let Some(ref local_var_str) = action__nisw {
6195        local_var_req_builder = match "multi" {
6196            "multi" => local_var_req_builder.query(
6197                &local_var_str
6198                    .into_iter()
6199                    .map(|p| ("action__nisw".to_owned(), p.to_string()))
6200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6201            ),
6202            _ => local_var_req_builder.query(&[(
6203                "action__nisw",
6204                &local_var_str
6205                    .into_iter()
6206                    .map(|p| p.to_string())
6207                    .collect::<Vec<String>>()
6208                    .join(",")
6209                    .to_string(),
6210            )]),
6211        };
6212    }
6213    if let Some(ref local_var_str) = action__regex {
6214        local_var_req_builder = match "multi" {
6215            "multi" => local_var_req_builder.query(
6216                &local_var_str
6217                    .into_iter()
6218                    .map(|p| ("action__regex".to_owned(), p.to_string()))
6219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6220            ),
6221            _ => local_var_req_builder.query(&[(
6222                "action__regex",
6223                &local_var_str
6224                    .into_iter()
6225                    .map(|p| p.to_string())
6226                    .collect::<Vec<String>>()
6227                    .join(",")
6228                    .to_string(),
6229            )]),
6230        };
6231    }
6232    if let Some(ref local_var_str) = changed_object_id {
6233        local_var_req_builder = match "multi" {
6234            "multi" => local_var_req_builder.query(
6235                &local_var_str
6236                    .into_iter()
6237                    .map(|p| ("changed_object_id".to_owned(), p.to_string()))
6238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6239            ),
6240            _ => local_var_req_builder.query(&[(
6241                "changed_object_id",
6242                &local_var_str
6243                    .into_iter()
6244                    .map(|p| p.to_string())
6245                    .collect::<Vec<String>>()
6246                    .join(",")
6247                    .to_string(),
6248            )]),
6249        };
6250    }
6251    if let Some(ref local_var_str) = changed_object_id__empty {
6252        local_var_req_builder = local_var_req_builder
6253            .query(&[("changed_object_id__empty", &local_var_str.to_string())]);
6254    }
6255    if let Some(ref local_var_str) = changed_object_id__gt {
6256        local_var_req_builder = match "multi" {
6257            "multi" => local_var_req_builder.query(
6258                &local_var_str
6259                    .into_iter()
6260                    .map(|p| ("changed_object_id__gt".to_owned(), p.to_string()))
6261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6262            ),
6263            _ => local_var_req_builder.query(&[(
6264                "changed_object_id__gt",
6265                &local_var_str
6266                    .into_iter()
6267                    .map(|p| p.to_string())
6268                    .collect::<Vec<String>>()
6269                    .join(",")
6270                    .to_string(),
6271            )]),
6272        };
6273    }
6274    if let Some(ref local_var_str) = changed_object_id__gte {
6275        local_var_req_builder = match "multi" {
6276            "multi" => local_var_req_builder.query(
6277                &local_var_str
6278                    .into_iter()
6279                    .map(|p| ("changed_object_id__gte".to_owned(), p.to_string()))
6280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6281            ),
6282            _ => local_var_req_builder.query(&[(
6283                "changed_object_id__gte",
6284                &local_var_str
6285                    .into_iter()
6286                    .map(|p| p.to_string())
6287                    .collect::<Vec<String>>()
6288                    .join(",")
6289                    .to_string(),
6290            )]),
6291        };
6292    }
6293    if let Some(ref local_var_str) = changed_object_id__lt {
6294        local_var_req_builder = match "multi" {
6295            "multi" => local_var_req_builder.query(
6296                &local_var_str
6297                    .into_iter()
6298                    .map(|p| ("changed_object_id__lt".to_owned(), p.to_string()))
6299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6300            ),
6301            _ => local_var_req_builder.query(&[(
6302                "changed_object_id__lt",
6303                &local_var_str
6304                    .into_iter()
6305                    .map(|p| p.to_string())
6306                    .collect::<Vec<String>>()
6307                    .join(",")
6308                    .to_string(),
6309            )]),
6310        };
6311    }
6312    if let Some(ref local_var_str) = changed_object_id__lte {
6313        local_var_req_builder = match "multi" {
6314            "multi" => local_var_req_builder.query(
6315                &local_var_str
6316                    .into_iter()
6317                    .map(|p| ("changed_object_id__lte".to_owned(), p.to_string()))
6318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6319            ),
6320            _ => local_var_req_builder.query(&[(
6321                "changed_object_id__lte",
6322                &local_var_str
6323                    .into_iter()
6324                    .map(|p| p.to_string())
6325                    .collect::<Vec<String>>()
6326                    .join(",")
6327                    .to_string(),
6328            )]),
6329        };
6330    }
6331    if let Some(ref local_var_str) = changed_object_id__n {
6332        local_var_req_builder = match "multi" {
6333            "multi" => local_var_req_builder.query(
6334                &local_var_str
6335                    .into_iter()
6336                    .map(|p| ("changed_object_id__n".to_owned(), p.to_string()))
6337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6338            ),
6339            _ => local_var_req_builder.query(&[(
6340                "changed_object_id__n",
6341                &local_var_str
6342                    .into_iter()
6343                    .map(|p| p.to_string())
6344                    .collect::<Vec<String>>()
6345                    .join(",")
6346                    .to_string(),
6347            )]),
6348        };
6349    }
6350    if let Some(ref local_var_str) = changed_object_type {
6351        local_var_req_builder = match "multi" {
6352            "multi" => local_var_req_builder.query(
6353                &local_var_str
6354                    .into_iter()
6355                    .map(|p| ("changed_object_type".to_owned(), p.to_string()))
6356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6357            ),
6358            _ => local_var_req_builder.query(&[(
6359                "changed_object_type",
6360                &local_var_str
6361                    .into_iter()
6362                    .map(|p| p.to_string())
6363                    .collect::<Vec<String>>()
6364                    .join(",")
6365                    .to_string(),
6366            )]),
6367        };
6368    }
6369    if let Some(ref local_var_str) = changed_object_type__n {
6370        local_var_req_builder = match "multi" {
6371            "multi" => local_var_req_builder.query(
6372                &local_var_str
6373                    .into_iter()
6374                    .map(|p| ("changed_object_type__n".to_owned(), p.to_string()))
6375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6376            ),
6377            _ => local_var_req_builder.query(&[(
6378                "changed_object_type__n",
6379                &local_var_str
6380                    .into_iter()
6381                    .map(|p| p.to_string())
6382                    .collect::<Vec<String>>()
6383                    .join(",")
6384                    .to_string(),
6385            )]),
6386        };
6387    }
6388    if let Some(ref local_var_str) = changed_object_type_id {
6389        local_var_req_builder = match "multi" {
6390            "multi" => local_var_req_builder.query(
6391                &local_var_str
6392                    .into_iter()
6393                    .map(|p| ("changed_object_type_id".to_owned(), p.to_string()))
6394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6395            ),
6396            _ => local_var_req_builder.query(&[(
6397                "changed_object_type_id",
6398                &local_var_str
6399                    .into_iter()
6400                    .map(|p| p.to_string())
6401                    .collect::<Vec<String>>()
6402                    .join(",")
6403                    .to_string(),
6404            )]),
6405        };
6406    }
6407    if let Some(ref local_var_str) = changed_object_type_id__n {
6408        local_var_req_builder = match "multi" {
6409            "multi" => local_var_req_builder.query(
6410                &local_var_str
6411                    .into_iter()
6412                    .map(|p| ("changed_object_type_id__n".to_owned(), p.to_string()))
6413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6414            ),
6415            _ => local_var_req_builder.query(&[(
6416                "changed_object_type_id__n",
6417                &local_var_str
6418                    .into_iter()
6419                    .map(|p| p.to_string())
6420                    .collect::<Vec<String>>()
6421                    .join(",")
6422                    .to_string(),
6423            )]),
6424        };
6425    }
6426    if let Some(ref local_var_str) = id {
6427        local_var_req_builder = match "multi" {
6428            "multi" => local_var_req_builder.query(
6429                &local_var_str
6430                    .into_iter()
6431                    .map(|p| ("id".to_owned(), p.to_string()))
6432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6433            ),
6434            _ => local_var_req_builder.query(&[(
6435                "id",
6436                &local_var_str
6437                    .into_iter()
6438                    .map(|p| p.to_string())
6439                    .collect::<Vec<String>>()
6440                    .join(",")
6441                    .to_string(),
6442            )]),
6443        };
6444    }
6445    if let Some(ref local_var_str) = id__empty {
6446        local_var_req_builder =
6447            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6448    }
6449    if let Some(ref local_var_str) = id__gt {
6450        local_var_req_builder = match "multi" {
6451            "multi" => local_var_req_builder.query(
6452                &local_var_str
6453                    .into_iter()
6454                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6456            ),
6457            _ => local_var_req_builder.query(&[(
6458                "id__gt",
6459                &local_var_str
6460                    .into_iter()
6461                    .map(|p| p.to_string())
6462                    .collect::<Vec<String>>()
6463                    .join(",")
6464                    .to_string(),
6465            )]),
6466        };
6467    }
6468    if let Some(ref local_var_str) = id__gte {
6469        local_var_req_builder = match "multi" {
6470            "multi" => local_var_req_builder.query(
6471                &local_var_str
6472                    .into_iter()
6473                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6475            ),
6476            _ => local_var_req_builder.query(&[(
6477                "id__gte",
6478                &local_var_str
6479                    .into_iter()
6480                    .map(|p| p.to_string())
6481                    .collect::<Vec<String>>()
6482                    .join(",")
6483                    .to_string(),
6484            )]),
6485        };
6486    }
6487    if let Some(ref local_var_str) = id__lt {
6488        local_var_req_builder = match "multi" {
6489            "multi" => local_var_req_builder.query(
6490                &local_var_str
6491                    .into_iter()
6492                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6494            ),
6495            _ => local_var_req_builder.query(&[(
6496                "id__lt",
6497                &local_var_str
6498                    .into_iter()
6499                    .map(|p| p.to_string())
6500                    .collect::<Vec<String>>()
6501                    .join(",")
6502                    .to_string(),
6503            )]),
6504        };
6505    }
6506    if let Some(ref local_var_str) = id__lte {
6507        local_var_req_builder = match "multi" {
6508            "multi" => local_var_req_builder.query(
6509                &local_var_str
6510                    .into_iter()
6511                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6513            ),
6514            _ => local_var_req_builder.query(&[(
6515                "id__lte",
6516                &local_var_str
6517                    .into_iter()
6518                    .map(|p| p.to_string())
6519                    .collect::<Vec<String>>()
6520                    .join(",")
6521                    .to_string(),
6522            )]),
6523        };
6524    }
6525    if let Some(ref local_var_str) = id__n {
6526        local_var_req_builder = match "multi" {
6527            "multi" => local_var_req_builder.query(
6528                &local_var_str
6529                    .into_iter()
6530                    .map(|p| ("id__n".to_owned(), p.to_string()))
6531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6532            ),
6533            _ => local_var_req_builder.query(&[(
6534                "id__n",
6535                &local_var_str
6536                    .into_iter()
6537                    .map(|p| p.to_string())
6538                    .collect::<Vec<String>>()
6539                    .join(",")
6540                    .to_string(),
6541            )]),
6542        };
6543    }
6544    if let Some(ref local_var_str) = limit {
6545        local_var_req_builder =
6546            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6547    }
6548    if let Some(ref local_var_str) = object_repr {
6549        local_var_req_builder = match "multi" {
6550            "multi" => local_var_req_builder.query(
6551                &local_var_str
6552                    .into_iter()
6553                    .map(|p| ("object_repr".to_owned(), p.to_string()))
6554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6555            ),
6556            _ => local_var_req_builder.query(&[(
6557                "object_repr",
6558                &local_var_str
6559                    .into_iter()
6560                    .map(|p| p.to_string())
6561                    .collect::<Vec<String>>()
6562                    .join(",")
6563                    .to_string(),
6564            )]),
6565        };
6566    }
6567    if let Some(ref local_var_str) = object_repr__empty {
6568        local_var_req_builder =
6569            local_var_req_builder.query(&[("object_repr__empty", &local_var_str.to_string())]);
6570    }
6571    if let Some(ref local_var_str) = object_repr__ic {
6572        local_var_req_builder = match "multi" {
6573            "multi" => local_var_req_builder.query(
6574                &local_var_str
6575                    .into_iter()
6576                    .map(|p| ("object_repr__ic".to_owned(), p.to_string()))
6577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6578            ),
6579            _ => local_var_req_builder.query(&[(
6580                "object_repr__ic",
6581                &local_var_str
6582                    .into_iter()
6583                    .map(|p| p.to_string())
6584                    .collect::<Vec<String>>()
6585                    .join(",")
6586                    .to_string(),
6587            )]),
6588        };
6589    }
6590    if let Some(ref local_var_str) = object_repr__ie {
6591        local_var_req_builder = match "multi" {
6592            "multi" => local_var_req_builder.query(
6593                &local_var_str
6594                    .into_iter()
6595                    .map(|p| ("object_repr__ie".to_owned(), p.to_string()))
6596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6597            ),
6598            _ => local_var_req_builder.query(&[(
6599                "object_repr__ie",
6600                &local_var_str
6601                    .into_iter()
6602                    .map(|p| p.to_string())
6603                    .collect::<Vec<String>>()
6604                    .join(",")
6605                    .to_string(),
6606            )]),
6607        };
6608    }
6609    if let Some(ref local_var_str) = object_repr__iew {
6610        local_var_req_builder = match "multi" {
6611            "multi" => local_var_req_builder.query(
6612                &local_var_str
6613                    .into_iter()
6614                    .map(|p| ("object_repr__iew".to_owned(), p.to_string()))
6615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6616            ),
6617            _ => local_var_req_builder.query(&[(
6618                "object_repr__iew",
6619                &local_var_str
6620                    .into_iter()
6621                    .map(|p| p.to_string())
6622                    .collect::<Vec<String>>()
6623                    .join(",")
6624                    .to_string(),
6625            )]),
6626        };
6627    }
6628    if let Some(ref local_var_str) = object_repr__iregex {
6629        local_var_req_builder = match "multi" {
6630            "multi" => local_var_req_builder.query(
6631                &local_var_str
6632                    .into_iter()
6633                    .map(|p| ("object_repr__iregex".to_owned(), p.to_string()))
6634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6635            ),
6636            _ => local_var_req_builder.query(&[(
6637                "object_repr__iregex",
6638                &local_var_str
6639                    .into_iter()
6640                    .map(|p| p.to_string())
6641                    .collect::<Vec<String>>()
6642                    .join(",")
6643                    .to_string(),
6644            )]),
6645        };
6646    }
6647    if let Some(ref local_var_str) = object_repr__isw {
6648        local_var_req_builder = match "multi" {
6649            "multi" => local_var_req_builder.query(
6650                &local_var_str
6651                    .into_iter()
6652                    .map(|p| ("object_repr__isw".to_owned(), p.to_string()))
6653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6654            ),
6655            _ => local_var_req_builder.query(&[(
6656                "object_repr__isw",
6657                &local_var_str
6658                    .into_iter()
6659                    .map(|p| p.to_string())
6660                    .collect::<Vec<String>>()
6661                    .join(",")
6662                    .to_string(),
6663            )]),
6664        };
6665    }
6666    if let Some(ref local_var_str) = object_repr__n {
6667        local_var_req_builder = match "multi" {
6668            "multi" => local_var_req_builder.query(
6669                &local_var_str
6670                    .into_iter()
6671                    .map(|p| ("object_repr__n".to_owned(), p.to_string()))
6672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6673            ),
6674            _ => local_var_req_builder.query(&[(
6675                "object_repr__n",
6676                &local_var_str
6677                    .into_iter()
6678                    .map(|p| p.to_string())
6679                    .collect::<Vec<String>>()
6680                    .join(",")
6681                    .to_string(),
6682            )]),
6683        };
6684    }
6685    if let Some(ref local_var_str) = object_repr__nic {
6686        local_var_req_builder = match "multi" {
6687            "multi" => local_var_req_builder.query(
6688                &local_var_str
6689                    .into_iter()
6690                    .map(|p| ("object_repr__nic".to_owned(), p.to_string()))
6691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6692            ),
6693            _ => local_var_req_builder.query(&[(
6694                "object_repr__nic",
6695                &local_var_str
6696                    .into_iter()
6697                    .map(|p| p.to_string())
6698                    .collect::<Vec<String>>()
6699                    .join(",")
6700                    .to_string(),
6701            )]),
6702        };
6703    }
6704    if let Some(ref local_var_str) = object_repr__nie {
6705        local_var_req_builder = match "multi" {
6706            "multi" => local_var_req_builder.query(
6707                &local_var_str
6708                    .into_iter()
6709                    .map(|p| ("object_repr__nie".to_owned(), p.to_string()))
6710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6711            ),
6712            _ => local_var_req_builder.query(&[(
6713                "object_repr__nie",
6714                &local_var_str
6715                    .into_iter()
6716                    .map(|p| p.to_string())
6717                    .collect::<Vec<String>>()
6718                    .join(",")
6719                    .to_string(),
6720            )]),
6721        };
6722    }
6723    if let Some(ref local_var_str) = object_repr__niew {
6724        local_var_req_builder = match "multi" {
6725            "multi" => local_var_req_builder.query(
6726                &local_var_str
6727                    .into_iter()
6728                    .map(|p| ("object_repr__niew".to_owned(), p.to_string()))
6729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6730            ),
6731            _ => local_var_req_builder.query(&[(
6732                "object_repr__niew",
6733                &local_var_str
6734                    .into_iter()
6735                    .map(|p| p.to_string())
6736                    .collect::<Vec<String>>()
6737                    .join(",")
6738                    .to_string(),
6739            )]),
6740        };
6741    }
6742    if let Some(ref local_var_str) = object_repr__nisw {
6743        local_var_req_builder = match "multi" {
6744            "multi" => local_var_req_builder.query(
6745                &local_var_str
6746                    .into_iter()
6747                    .map(|p| ("object_repr__nisw".to_owned(), p.to_string()))
6748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6749            ),
6750            _ => local_var_req_builder.query(&[(
6751                "object_repr__nisw",
6752                &local_var_str
6753                    .into_iter()
6754                    .map(|p| p.to_string())
6755                    .collect::<Vec<String>>()
6756                    .join(",")
6757                    .to_string(),
6758            )]),
6759        };
6760    }
6761    if let Some(ref local_var_str) = object_repr__regex {
6762        local_var_req_builder = match "multi" {
6763            "multi" => local_var_req_builder.query(
6764                &local_var_str
6765                    .into_iter()
6766                    .map(|p| ("object_repr__regex".to_owned(), p.to_string()))
6767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6768            ),
6769            _ => local_var_req_builder.query(&[(
6770                "object_repr__regex",
6771                &local_var_str
6772                    .into_iter()
6773                    .map(|p| p.to_string())
6774                    .collect::<Vec<String>>()
6775                    .join(",")
6776                    .to_string(),
6777            )]),
6778        };
6779    }
6780    if let Some(ref local_var_str) = offset {
6781        local_var_req_builder =
6782            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6783    }
6784    if let Some(ref local_var_str) = ordering {
6785        local_var_req_builder =
6786            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
6787    }
6788    if let Some(ref local_var_str) = q {
6789        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6790    }
6791    if let Some(ref local_var_str) = related_object_id {
6792        local_var_req_builder = match "multi" {
6793            "multi" => local_var_req_builder.query(
6794                &local_var_str
6795                    .into_iter()
6796                    .map(|p| ("related_object_id".to_owned(), p.to_string()))
6797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6798            ),
6799            _ => local_var_req_builder.query(&[(
6800                "related_object_id",
6801                &local_var_str
6802                    .into_iter()
6803                    .map(|p| p.to_string())
6804                    .collect::<Vec<String>>()
6805                    .join(",")
6806                    .to_string(),
6807            )]),
6808        };
6809    }
6810    if let Some(ref local_var_str) = related_object_id__empty {
6811        local_var_req_builder = local_var_req_builder
6812            .query(&[("related_object_id__empty", &local_var_str.to_string())]);
6813    }
6814    if let Some(ref local_var_str) = related_object_id__gt {
6815        local_var_req_builder = match "multi" {
6816            "multi" => local_var_req_builder.query(
6817                &local_var_str
6818                    .into_iter()
6819                    .map(|p| ("related_object_id__gt".to_owned(), p.to_string()))
6820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6821            ),
6822            _ => local_var_req_builder.query(&[(
6823                "related_object_id__gt",
6824                &local_var_str
6825                    .into_iter()
6826                    .map(|p| p.to_string())
6827                    .collect::<Vec<String>>()
6828                    .join(",")
6829                    .to_string(),
6830            )]),
6831        };
6832    }
6833    if let Some(ref local_var_str) = related_object_id__gte {
6834        local_var_req_builder = match "multi" {
6835            "multi" => local_var_req_builder.query(
6836                &local_var_str
6837                    .into_iter()
6838                    .map(|p| ("related_object_id__gte".to_owned(), p.to_string()))
6839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6840            ),
6841            _ => local_var_req_builder.query(&[(
6842                "related_object_id__gte",
6843                &local_var_str
6844                    .into_iter()
6845                    .map(|p| p.to_string())
6846                    .collect::<Vec<String>>()
6847                    .join(",")
6848                    .to_string(),
6849            )]),
6850        };
6851    }
6852    if let Some(ref local_var_str) = related_object_id__lt {
6853        local_var_req_builder = match "multi" {
6854            "multi" => local_var_req_builder.query(
6855                &local_var_str
6856                    .into_iter()
6857                    .map(|p| ("related_object_id__lt".to_owned(), p.to_string()))
6858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6859            ),
6860            _ => local_var_req_builder.query(&[(
6861                "related_object_id__lt",
6862                &local_var_str
6863                    .into_iter()
6864                    .map(|p| p.to_string())
6865                    .collect::<Vec<String>>()
6866                    .join(",")
6867                    .to_string(),
6868            )]),
6869        };
6870    }
6871    if let Some(ref local_var_str) = related_object_id__lte {
6872        local_var_req_builder = match "multi" {
6873            "multi" => local_var_req_builder.query(
6874                &local_var_str
6875                    .into_iter()
6876                    .map(|p| ("related_object_id__lte".to_owned(), p.to_string()))
6877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6878            ),
6879            _ => local_var_req_builder.query(&[(
6880                "related_object_id__lte",
6881                &local_var_str
6882                    .into_iter()
6883                    .map(|p| p.to_string())
6884                    .collect::<Vec<String>>()
6885                    .join(",")
6886                    .to_string(),
6887            )]),
6888        };
6889    }
6890    if let Some(ref local_var_str) = related_object_id__n {
6891        local_var_req_builder = match "multi" {
6892            "multi" => local_var_req_builder.query(
6893                &local_var_str
6894                    .into_iter()
6895                    .map(|p| ("related_object_id__n".to_owned(), p.to_string()))
6896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6897            ),
6898            _ => local_var_req_builder.query(&[(
6899                "related_object_id__n",
6900                &local_var_str
6901                    .into_iter()
6902                    .map(|p| p.to_string())
6903                    .collect::<Vec<String>>()
6904                    .join(",")
6905                    .to_string(),
6906            )]),
6907        };
6908    }
6909    if let Some(ref local_var_str) = related_object_type {
6910        local_var_req_builder = match "multi" {
6911            "multi" => local_var_req_builder.query(
6912                &local_var_str
6913                    .into_iter()
6914                    .map(|p| ("related_object_type".to_owned(), p.to_string()))
6915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6916            ),
6917            _ => local_var_req_builder.query(&[(
6918                "related_object_type",
6919                &local_var_str
6920                    .into_iter()
6921                    .map(|p| p.to_string())
6922                    .collect::<Vec<String>>()
6923                    .join(",")
6924                    .to_string(),
6925            )]),
6926        };
6927    }
6928    if let Some(ref local_var_str) = related_object_type__n {
6929        local_var_req_builder = match "multi" {
6930            "multi" => local_var_req_builder.query(
6931                &local_var_str
6932                    .into_iter()
6933                    .map(|p| ("related_object_type__n".to_owned(), p.to_string()))
6934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6935            ),
6936            _ => local_var_req_builder.query(&[(
6937                "related_object_type__n",
6938                &local_var_str
6939                    .into_iter()
6940                    .map(|p| p.to_string())
6941                    .collect::<Vec<String>>()
6942                    .join(",")
6943                    .to_string(),
6944            )]),
6945        };
6946    }
6947    if let Some(ref local_var_str) = request_id {
6948        local_var_req_builder =
6949            local_var_req_builder.query(&[("request_id", &local_var_str.to_string())]);
6950    }
6951    if let Some(ref local_var_str) = time_after {
6952        local_var_req_builder =
6953            local_var_req_builder.query(&[("time_after", &local_var_str.to_string())]);
6954    }
6955    if let Some(ref local_var_str) = time_before {
6956        local_var_req_builder =
6957            local_var_req_builder.query(&[("time_before", &local_var_str.to_string())]);
6958    }
6959    if let Some(ref local_var_str) = user {
6960        local_var_req_builder = match "multi" {
6961            "multi" => local_var_req_builder.query(
6962                &local_var_str
6963                    .into_iter()
6964                    .map(|p| ("user".to_owned(), p.to_string()))
6965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6966            ),
6967            _ => local_var_req_builder.query(&[(
6968                "user",
6969                &local_var_str
6970                    .into_iter()
6971                    .map(|p| p.to_string())
6972                    .collect::<Vec<String>>()
6973                    .join(",")
6974                    .to_string(),
6975            )]),
6976        };
6977    }
6978    if let Some(ref local_var_str) = user__n {
6979        local_var_req_builder = match "multi" {
6980            "multi" => local_var_req_builder.query(
6981                &local_var_str
6982                    .into_iter()
6983                    .map(|p| ("user__n".to_owned(), p.to_string()))
6984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6985            ),
6986            _ => local_var_req_builder.query(&[(
6987                "user__n",
6988                &local_var_str
6989                    .into_iter()
6990                    .map(|p| p.to_string())
6991                    .collect::<Vec<String>>()
6992                    .join(",")
6993                    .to_string(),
6994            )]),
6995        };
6996    }
6997    if let Some(ref local_var_str) = user_id {
6998        local_var_req_builder = match "multi" {
6999            "multi" => local_var_req_builder.query(
7000                &local_var_str
7001                    .into_iter()
7002                    .map(|p| ("user_id".to_owned(), p.to_string()))
7003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7004            ),
7005            _ => local_var_req_builder.query(&[(
7006                "user_id",
7007                &local_var_str
7008                    .into_iter()
7009                    .map(|p| p.to_string())
7010                    .collect::<Vec<String>>()
7011                    .join(",")
7012                    .to_string(),
7013            )]),
7014        };
7015    }
7016    if let Some(ref local_var_str) = user_id__n {
7017        local_var_req_builder = match "multi" {
7018            "multi" => local_var_req_builder.query(
7019                &local_var_str
7020                    .into_iter()
7021                    .map(|p| ("user_id__n".to_owned(), p.to_string()))
7022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7023            ),
7024            _ => local_var_req_builder.query(&[(
7025                "user_id__n",
7026                &local_var_str
7027                    .into_iter()
7028                    .map(|p| p.to_string())
7029                    .collect::<Vec<String>>()
7030                    .join(",")
7031                    .to_string(),
7032            )]),
7033        };
7034    }
7035    if let Some(ref local_var_str) = user_name {
7036        local_var_req_builder = match "multi" {
7037            "multi" => local_var_req_builder.query(
7038                &local_var_str
7039                    .into_iter()
7040                    .map(|p| ("user_name".to_owned(), p.to_string()))
7041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7042            ),
7043            _ => local_var_req_builder.query(&[(
7044                "user_name",
7045                &local_var_str
7046                    .into_iter()
7047                    .map(|p| p.to_string())
7048                    .collect::<Vec<String>>()
7049                    .join(",")
7050                    .to_string(),
7051            )]),
7052        };
7053    }
7054    if let Some(ref local_var_str) = user_name__empty {
7055        local_var_req_builder =
7056            local_var_req_builder.query(&[("user_name__empty", &local_var_str.to_string())]);
7057    }
7058    if let Some(ref local_var_str) = user_name__ic {
7059        local_var_req_builder = match "multi" {
7060            "multi" => local_var_req_builder.query(
7061                &local_var_str
7062                    .into_iter()
7063                    .map(|p| ("user_name__ic".to_owned(), p.to_string()))
7064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7065            ),
7066            _ => local_var_req_builder.query(&[(
7067                "user_name__ic",
7068                &local_var_str
7069                    .into_iter()
7070                    .map(|p| p.to_string())
7071                    .collect::<Vec<String>>()
7072                    .join(",")
7073                    .to_string(),
7074            )]),
7075        };
7076    }
7077    if let Some(ref local_var_str) = user_name__ie {
7078        local_var_req_builder = match "multi" {
7079            "multi" => local_var_req_builder.query(
7080                &local_var_str
7081                    .into_iter()
7082                    .map(|p| ("user_name__ie".to_owned(), p.to_string()))
7083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7084            ),
7085            _ => local_var_req_builder.query(&[(
7086                "user_name__ie",
7087                &local_var_str
7088                    .into_iter()
7089                    .map(|p| p.to_string())
7090                    .collect::<Vec<String>>()
7091                    .join(",")
7092                    .to_string(),
7093            )]),
7094        };
7095    }
7096    if let Some(ref local_var_str) = user_name__iew {
7097        local_var_req_builder = match "multi" {
7098            "multi" => local_var_req_builder.query(
7099                &local_var_str
7100                    .into_iter()
7101                    .map(|p| ("user_name__iew".to_owned(), p.to_string()))
7102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7103            ),
7104            _ => local_var_req_builder.query(&[(
7105                "user_name__iew",
7106                &local_var_str
7107                    .into_iter()
7108                    .map(|p| p.to_string())
7109                    .collect::<Vec<String>>()
7110                    .join(",")
7111                    .to_string(),
7112            )]),
7113        };
7114    }
7115    if let Some(ref local_var_str) = user_name__iregex {
7116        local_var_req_builder = match "multi" {
7117            "multi" => local_var_req_builder.query(
7118                &local_var_str
7119                    .into_iter()
7120                    .map(|p| ("user_name__iregex".to_owned(), p.to_string()))
7121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7122            ),
7123            _ => local_var_req_builder.query(&[(
7124                "user_name__iregex",
7125                &local_var_str
7126                    .into_iter()
7127                    .map(|p| p.to_string())
7128                    .collect::<Vec<String>>()
7129                    .join(",")
7130                    .to_string(),
7131            )]),
7132        };
7133    }
7134    if let Some(ref local_var_str) = user_name__isw {
7135        local_var_req_builder = match "multi" {
7136            "multi" => local_var_req_builder.query(
7137                &local_var_str
7138                    .into_iter()
7139                    .map(|p| ("user_name__isw".to_owned(), p.to_string()))
7140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7141            ),
7142            _ => local_var_req_builder.query(&[(
7143                "user_name__isw",
7144                &local_var_str
7145                    .into_iter()
7146                    .map(|p| p.to_string())
7147                    .collect::<Vec<String>>()
7148                    .join(",")
7149                    .to_string(),
7150            )]),
7151        };
7152    }
7153    if let Some(ref local_var_str) = user_name__n {
7154        local_var_req_builder = match "multi" {
7155            "multi" => local_var_req_builder.query(
7156                &local_var_str
7157                    .into_iter()
7158                    .map(|p| ("user_name__n".to_owned(), p.to_string()))
7159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7160            ),
7161            _ => local_var_req_builder.query(&[(
7162                "user_name__n",
7163                &local_var_str
7164                    .into_iter()
7165                    .map(|p| p.to_string())
7166                    .collect::<Vec<String>>()
7167                    .join(",")
7168                    .to_string(),
7169            )]),
7170        };
7171    }
7172    if let Some(ref local_var_str) = user_name__nic {
7173        local_var_req_builder = match "multi" {
7174            "multi" => local_var_req_builder.query(
7175                &local_var_str
7176                    .into_iter()
7177                    .map(|p| ("user_name__nic".to_owned(), p.to_string()))
7178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7179            ),
7180            _ => local_var_req_builder.query(&[(
7181                "user_name__nic",
7182                &local_var_str
7183                    .into_iter()
7184                    .map(|p| p.to_string())
7185                    .collect::<Vec<String>>()
7186                    .join(",")
7187                    .to_string(),
7188            )]),
7189        };
7190    }
7191    if let Some(ref local_var_str) = user_name__nie {
7192        local_var_req_builder = match "multi" {
7193            "multi" => local_var_req_builder.query(
7194                &local_var_str
7195                    .into_iter()
7196                    .map(|p| ("user_name__nie".to_owned(), p.to_string()))
7197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7198            ),
7199            _ => local_var_req_builder.query(&[(
7200                "user_name__nie",
7201                &local_var_str
7202                    .into_iter()
7203                    .map(|p| p.to_string())
7204                    .collect::<Vec<String>>()
7205                    .join(",")
7206                    .to_string(),
7207            )]),
7208        };
7209    }
7210    if let Some(ref local_var_str) = user_name__niew {
7211        local_var_req_builder = match "multi" {
7212            "multi" => local_var_req_builder.query(
7213                &local_var_str
7214                    .into_iter()
7215                    .map(|p| ("user_name__niew".to_owned(), p.to_string()))
7216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7217            ),
7218            _ => local_var_req_builder.query(&[(
7219                "user_name__niew",
7220                &local_var_str
7221                    .into_iter()
7222                    .map(|p| p.to_string())
7223                    .collect::<Vec<String>>()
7224                    .join(",")
7225                    .to_string(),
7226            )]),
7227        };
7228    }
7229    if let Some(ref local_var_str) = user_name__nisw {
7230        local_var_req_builder = match "multi" {
7231            "multi" => local_var_req_builder.query(
7232                &local_var_str
7233                    .into_iter()
7234                    .map(|p| ("user_name__nisw".to_owned(), p.to_string()))
7235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7236            ),
7237            _ => local_var_req_builder.query(&[(
7238                "user_name__nisw",
7239                &local_var_str
7240                    .into_iter()
7241                    .map(|p| p.to_string())
7242                    .collect::<Vec<String>>()
7243                    .join(",")
7244                    .to_string(),
7245            )]),
7246        };
7247    }
7248    if let Some(ref local_var_str) = user_name__regex {
7249        local_var_req_builder = match "multi" {
7250            "multi" => local_var_req_builder.query(
7251                &local_var_str
7252                    .into_iter()
7253                    .map(|p| ("user_name__regex".to_owned(), p.to_string()))
7254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7255            ),
7256            _ => local_var_req_builder.query(&[(
7257                "user_name__regex",
7258                &local_var_str
7259                    .into_iter()
7260                    .map(|p| p.to_string())
7261                    .collect::<Vec<String>>()
7262                    .join(",")
7263                    .to_string(),
7264            )]),
7265        };
7266    }
7267    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7268        local_var_req_builder =
7269            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7270    }
7271    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7272        let local_var_key = local_var_apikey.key.clone();
7273        let local_var_value = match local_var_apikey.prefix {
7274            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7275            None => local_var_key,
7276        };
7277        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7278    };
7279
7280    let local_var_req = local_var_req_builder.build()?;
7281    let local_var_resp = local_var_client.execute(local_var_req).await?;
7282
7283    let local_var_status = local_var_resp.status();
7284    let local_var_content = local_var_resp.text().await?;
7285
7286    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7287        serde_json::from_str(&local_var_content).map_err(Error::from)
7288    } else {
7289        let local_var_entity: Option<CoreObjectChangesListError> =
7290            serde_json::from_str(&local_var_content).ok();
7291        let local_var_error = ResponseContent {
7292            status: local_var_status,
7293            content: local_var_content,
7294            entity: local_var_entity,
7295        };
7296        Err(Error::ResponseError(local_var_error))
7297    }
7298}
7299
7300/// Retrieve a list of recent changes.
7301pub async fn core_object_changes_retrieve(
7302    configuration: &configuration::Configuration,
7303    id: i32,
7304) -> Result<crate::models::ObjectChange, Error<CoreObjectChangesRetrieveError>> {
7305    let local_var_configuration = configuration;
7306
7307    let local_var_client = &local_var_configuration.client;
7308
7309    let local_var_uri_str = format!(
7310        "{}/api/core/object-changes/{id}/",
7311        local_var_configuration.base_path,
7312        id = id
7313    );
7314    let mut local_var_req_builder =
7315        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7316
7317    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7318        local_var_req_builder =
7319            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7320    }
7321    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7322        let local_var_key = local_var_apikey.key.clone();
7323        let local_var_value = match local_var_apikey.prefix {
7324            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7325            None => local_var_key,
7326        };
7327        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7328    };
7329
7330    let local_var_req = local_var_req_builder.build()?;
7331    let local_var_resp = local_var_client.execute(local_var_req).await?;
7332
7333    let local_var_status = local_var_resp.status();
7334    let local_var_content = local_var_resp.text().await?;
7335
7336    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7337        serde_json::from_str(&local_var_content).map_err(Error::from)
7338    } else {
7339        let local_var_entity: Option<CoreObjectChangesRetrieveError> =
7340            serde_json::from_str(&local_var_content).ok();
7341        let local_var_error = ResponseContent {
7342            status: local_var_status,
7343            content: local_var_content,
7344            entity: local_var_entity,
7345        };
7346        Err(Error::ResponseError(local_var_error))
7347    }
7348}
7349
7350/// Read-only list of ObjectTypes.
7351pub async fn core_object_types_list(
7352    configuration: &configuration::Configuration,
7353    app_label: Option<Vec<String>>,
7354    app_label__empty: Option<bool>,
7355    app_label__ic: Option<Vec<String>>,
7356    app_label__ie: Option<Vec<String>>,
7357    app_label__iew: Option<Vec<String>>,
7358    app_label__iregex: Option<Vec<String>>,
7359    app_label__isw: Option<Vec<String>>,
7360    app_label__n: Option<Vec<String>>,
7361    app_label__nic: Option<Vec<String>>,
7362    app_label__nie: Option<Vec<String>>,
7363    app_label__niew: Option<Vec<String>>,
7364    app_label__nisw: Option<Vec<String>>,
7365    app_label__regex: Option<Vec<String>>,
7366    features: Option<&str>,
7367    id: Option<Vec<i32>>,
7368    id__empty: Option<bool>,
7369    id__gt: Option<Vec<i32>>,
7370    id__gte: Option<Vec<i32>>,
7371    id__lt: Option<Vec<i32>>,
7372    id__lte: Option<Vec<i32>>,
7373    id__n: Option<Vec<i32>>,
7374    limit: Option<i32>,
7375    model: Option<Vec<String>>,
7376    model__empty: Option<bool>,
7377    model__ic: Option<Vec<String>>,
7378    model__ie: Option<Vec<String>>,
7379    model__iew: Option<Vec<String>>,
7380    model__iregex: Option<Vec<String>>,
7381    model__isw: Option<Vec<String>>,
7382    model__n: Option<Vec<String>>,
7383    model__nic: Option<Vec<String>>,
7384    model__nie: Option<Vec<String>>,
7385    model__niew: Option<Vec<String>>,
7386    model__nisw: Option<Vec<String>>,
7387    model__regex: Option<Vec<String>>,
7388    offset: Option<i32>,
7389    ordering: Option<&str>,
7390    public: Option<bool>,
7391    q: Option<&str>,
7392) -> Result<crate::models::PaginatedObjectTypeList, Error<CoreObjectTypesListError>> {
7393    let local_var_configuration = configuration;
7394
7395    let local_var_client = &local_var_configuration.client;
7396
7397    let local_var_uri_str = format!(
7398        "{}/api/core/object-types/",
7399        local_var_configuration.base_path
7400    );
7401    let mut local_var_req_builder =
7402        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7403
7404    if let Some(ref local_var_str) = app_label {
7405        local_var_req_builder = match "multi" {
7406            "multi" => local_var_req_builder.query(
7407                &local_var_str
7408                    .into_iter()
7409                    .map(|p| ("app_label".to_owned(), p.to_string()))
7410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7411            ),
7412            _ => local_var_req_builder.query(&[(
7413                "app_label",
7414                &local_var_str
7415                    .into_iter()
7416                    .map(|p| p.to_string())
7417                    .collect::<Vec<String>>()
7418                    .join(",")
7419                    .to_string(),
7420            )]),
7421        };
7422    }
7423    if let Some(ref local_var_str) = app_label__empty {
7424        local_var_req_builder =
7425            local_var_req_builder.query(&[("app_label__empty", &local_var_str.to_string())]);
7426    }
7427    if let Some(ref local_var_str) = app_label__ic {
7428        local_var_req_builder = match "multi" {
7429            "multi" => local_var_req_builder.query(
7430                &local_var_str
7431                    .into_iter()
7432                    .map(|p| ("app_label__ic".to_owned(), p.to_string()))
7433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7434            ),
7435            _ => local_var_req_builder.query(&[(
7436                "app_label__ic",
7437                &local_var_str
7438                    .into_iter()
7439                    .map(|p| p.to_string())
7440                    .collect::<Vec<String>>()
7441                    .join(",")
7442                    .to_string(),
7443            )]),
7444        };
7445    }
7446    if let Some(ref local_var_str) = app_label__ie {
7447        local_var_req_builder = match "multi" {
7448            "multi" => local_var_req_builder.query(
7449                &local_var_str
7450                    .into_iter()
7451                    .map(|p| ("app_label__ie".to_owned(), p.to_string()))
7452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7453            ),
7454            _ => local_var_req_builder.query(&[(
7455                "app_label__ie",
7456                &local_var_str
7457                    .into_iter()
7458                    .map(|p| p.to_string())
7459                    .collect::<Vec<String>>()
7460                    .join(",")
7461                    .to_string(),
7462            )]),
7463        };
7464    }
7465    if let Some(ref local_var_str) = app_label__iew {
7466        local_var_req_builder = match "multi" {
7467            "multi" => local_var_req_builder.query(
7468                &local_var_str
7469                    .into_iter()
7470                    .map(|p| ("app_label__iew".to_owned(), p.to_string()))
7471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7472            ),
7473            _ => local_var_req_builder.query(&[(
7474                "app_label__iew",
7475                &local_var_str
7476                    .into_iter()
7477                    .map(|p| p.to_string())
7478                    .collect::<Vec<String>>()
7479                    .join(",")
7480                    .to_string(),
7481            )]),
7482        };
7483    }
7484    if let Some(ref local_var_str) = app_label__iregex {
7485        local_var_req_builder = match "multi" {
7486            "multi" => local_var_req_builder.query(
7487                &local_var_str
7488                    .into_iter()
7489                    .map(|p| ("app_label__iregex".to_owned(), p.to_string()))
7490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7491            ),
7492            _ => local_var_req_builder.query(&[(
7493                "app_label__iregex",
7494                &local_var_str
7495                    .into_iter()
7496                    .map(|p| p.to_string())
7497                    .collect::<Vec<String>>()
7498                    .join(",")
7499                    .to_string(),
7500            )]),
7501        };
7502    }
7503    if let Some(ref local_var_str) = app_label__isw {
7504        local_var_req_builder = match "multi" {
7505            "multi" => local_var_req_builder.query(
7506                &local_var_str
7507                    .into_iter()
7508                    .map(|p| ("app_label__isw".to_owned(), p.to_string()))
7509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7510            ),
7511            _ => local_var_req_builder.query(&[(
7512                "app_label__isw",
7513                &local_var_str
7514                    .into_iter()
7515                    .map(|p| p.to_string())
7516                    .collect::<Vec<String>>()
7517                    .join(",")
7518                    .to_string(),
7519            )]),
7520        };
7521    }
7522    if let Some(ref local_var_str) = app_label__n {
7523        local_var_req_builder = match "multi" {
7524            "multi" => local_var_req_builder.query(
7525                &local_var_str
7526                    .into_iter()
7527                    .map(|p| ("app_label__n".to_owned(), p.to_string()))
7528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7529            ),
7530            _ => local_var_req_builder.query(&[(
7531                "app_label__n",
7532                &local_var_str
7533                    .into_iter()
7534                    .map(|p| p.to_string())
7535                    .collect::<Vec<String>>()
7536                    .join(",")
7537                    .to_string(),
7538            )]),
7539        };
7540    }
7541    if let Some(ref local_var_str) = app_label__nic {
7542        local_var_req_builder = match "multi" {
7543            "multi" => local_var_req_builder.query(
7544                &local_var_str
7545                    .into_iter()
7546                    .map(|p| ("app_label__nic".to_owned(), p.to_string()))
7547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7548            ),
7549            _ => local_var_req_builder.query(&[(
7550                "app_label__nic",
7551                &local_var_str
7552                    .into_iter()
7553                    .map(|p| p.to_string())
7554                    .collect::<Vec<String>>()
7555                    .join(",")
7556                    .to_string(),
7557            )]),
7558        };
7559    }
7560    if let Some(ref local_var_str) = app_label__nie {
7561        local_var_req_builder = match "multi" {
7562            "multi" => local_var_req_builder.query(
7563                &local_var_str
7564                    .into_iter()
7565                    .map(|p| ("app_label__nie".to_owned(), p.to_string()))
7566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7567            ),
7568            _ => local_var_req_builder.query(&[(
7569                "app_label__nie",
7570                &local_var_str
7571                    .into_iter()
7572                    .map(|p| p.to_string())
7573                    .collect::<Vec<String>>()
7574                    .join(",")
7575                    .to_string(),
7576            )]),
7577        };
7578    }
7579    if let Some(ref local_var_str) = app_label__niew {
7580        local_var_req_builder = match "multi" {
7581            "multi" => local_var_req_builder.query(
7582                &local_var_str
7583                    .into_iter()
7584                    .map(|p| ("app_label__niew".to_owned(), p.to_string()))
7585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7586            ),
7587            _ => local_var_req_builder.query(&[(
7588                "app_label__niew",
7589                &local_var_str
7590                    .into_iter()
7591                    .map(|p| p.to_string())
7592                    .collect::<Vec<String>>()
7593                    .join(",")
7594                    .to_string(),
7595            )]),
7596        };
7597    }
7598    if let Some(ref local_var_str) = app_label__nisw {
7599        local_var_req_builder = match "multi" {
7600            "multi" => local_var_req_builder.query(
7601                &local_var_str
7602                    .into_iter()
7603                    .map(|p| ("app_label__nisw".to_owned(), p.to_string()))
7604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7605            ),
7606            _ => local_var_req_builder.query(&[(
7607                "app_label__nisw",
7608                &local_var_str
7609                    .into_iter()
7610                    .map(|p| p.to_string())
7611                    .collect::<Vec<String>>()
7612                    .join(",")
7613                    .to_string(),
7614            )]),
7615        };
7616    }
7617    if let Some(ref local_var_str) = app_label__regex {
7618        local_var_req_builder = match "multi" {
7619            "multi" => local_var_req_builder.query(
7620                &local_var_str
7621                    .into_iter()
7622                    .map(|p| ("app_label__regex".to_owned(), p.to_string()))
7623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7624            ),
7625            _ => local_var_req_builder.query(&[(
7626                "app_label__regex",
7627                &local_var_str
7628                    .into_iter()
7629                    .map(|p| p.to_string())
7630                    .collect::<Vec<String>>()
7631                    .join(",")
7632                    .to_string(),
7633            )]),
7634        };
7635    }
7636    if let Some(ref local_var_str) = features {
7637        local_var_req_builder =
7638            local_var_req_builder.query(&[("features", &local_var_str.to_string())]);
7639    }
7640    if let Some(ref local_var_str) = id {
7641        local_var_req_builder = match "multi" {
7642            "multi" => local_var_req_builder.query(
7643                &local_var_str
7644                    .into_iter()
7645                    .map(|p| ("id".to_owned(), p.to_string()))
7646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7647            ),
7648            _ => local_var_req_builder.query(&[(
7649                "id",
7650                &local_var_str
7651                    .into_iter()
7652                    .map(|p| p.to_string())
7653                    .collect::<Vec<String>>()
7654                    .join(",")
7655                    .to_string(),
7656            )]),
7657        };
7658    }
7659    if let Some(ref local_var_str) = id__empty {
7660        local_var_req_builder =
7661            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7662    }
7663    if let Some(ref local_var_str) = id__gt {
7664        local_var_req_builder = match "multi" {
7665            "multi" => local_var_req_builder.query(
7666                &local_var_str
7667                    .into_iter()
7668                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7670            ),
7671            _ => local_var_req_builder.query(&[(
7672                "id__gt",
7673                &local_var_str
7674                    .into_iter()
7675                    .map(|p| p.to_string())
7676                    .collect::<Vec<String>>()
7677                    .join(",")
7678                    .to_string(),
7679            )]),
7680        };
7681    }
7682    if let Some(ref local_var_str) = id__gte {
7683        local_var_req_builder = match "multi" {
7684            "multi" => local_var_req_builder.query(
7685                &local_var_str
7686                    .into_iter()
7687                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7689            ),
7690            _ => local_var_req_builder.query(&[(
7691                "id__gte",
7692                &local_var_str
7693                    .into_iter()
7694                    .map(|p| p.to_string())
7695                    .collect::<Vec<String>>()
7696                    .join(",")
7697                    .to_string(),
7698            )]),
7699        };
7700    }
7701    if let Some(ref local_var_str) = id__lt {
7702        local_var_req_builder = match "multi" {
7703            "multi" => local_var_req_builder.query(
7704                &local_var_str
7705                    .into_iter()
7706                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7708            ),
7709            _ => local_var_req_builder.query(&[(
7710                "id__lt",
7711                &local_var_str
7712                    .into_iter()
7713                    .map(|p| p.to_string())
7714                    .collect::<Vec<String>>()
7715                    .join(",")
7716                    .to_string(),
7717            )]),
7718        };
7719    }
7720    if let Some(ref local_var_str) = id__lte {
7721        local_var_req_builder = match "multi" {
7722            "multi" => local_var_req_builder.query(
7723                &local_var_str
7724                    .into_iter()
7725                    .map(|p| ("id__lte".to_owned(), p.to_string()))
7726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7727            ),
7728            _ => local_var_req_builder.query(&[(
7729                "id__lte",
7730                &local_var_str
7731                    .into_iter()
7732                    .map(|p| p.to_string())
7733                    .collect::<Vec<String>>()
7734                    .join(",")
7735                    .to_string(),
7736            )]),
7737        };
7738    }
7739    if let Some(ref local_var_str) = id__n {
7740        local_var_req_builder = match "multi" {
7741            "multi" => local_var_req_builder.query(
7742                &local_var_str
7743                    .into_iter()
7744                    .map(|p| ("id__n".to_owned(), p.to_string()))
7745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7746            ),
7747            _ => local_var_req_builder.query(&[(
7748                "id__n",
7749                &local_var_str
7750                    .into_iter()
7751                    .map(|p| p.to_string())
7752                    .collect::<Vec<String>>()
7753                    .join(",")
7754                    .to_string(),
7755            )]),
7756        };
7757    }
7758    if let Some(ref local_var_str) = limit {
7759        local_var_req_builder =
7760            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7761    }
7762    if let Some(ref local_var_str) = model {
7763        local_var_req_builder = match "multi" {
7764            "multi" => local_var_req_builder.query(
7765                &local_var_str
7766                    .into_iter()
7767                    .map(|p| ("model".to_owned(), p.to_string()))
7768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7769            ),
7770            _ => local_var_req_builder.query(&[(
7771                "model",
7772                &local_var_str
7773                    .into_iter()
7774                    .map(|p| p.to_string())
7775                    .collect::<Vec<String>>()
7776                    .join(",")
7777                    .to_string(),
7778            )]),
7779        };
7780    }
7781    if let Some(ref local_var_str) = model__empty {
7782        local_var_req_builder =
7783            local_var_req_builder.query(&[("model__empty", &local_var_str.to_string())]);
7784    }
7785    if let Some(ref local_var_str) = model__ic {
7786        local_var_req_builder = match "multi" {
7787            "multi" => local_var_req_builder.query(
7788                &local_var_str
7789                    .into_iter()
7790                    .map(|p| ("model__ic".to_owned(), p.to_string()))
7791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7792            ),
7793            _ => local_var_req_builder.query(&[(
7794                "model__ic",
7795                &local_var_str
7796                    .into_iter()
7797                    .map(|p| p.to_string())
7798                    .collect::<Vec<String>>()
7799                    .join(",")
7800                    .to_string(),
7801            )]),
7802        };
7803    }
7804    if let Some(ref local_var_str) = model__ie {
7805        local_var_req_builder = match "multi" {
7806            "multi" => local_var_req_builder.query(
7807                &local_var_str
7808                    .into_iter()
7809                    .map(|p| ("model__ie".to_owned(), p.to_string()))
7810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7811            ),
7812            _ => local_var_req_builder.query(&[(
7813                "model__ie",
7814                &local_var_str
7815                    .into_iter()
7816                    .map(|p| p.to_string())
7817                    .collect::<Vec<String>>()
7818                    .join(",")
7819                    .to_string(),
7820            )]),
7821        };
7822    }
7823    if let Some(ref local_var_str) = model__iew {
7824        local_var_req_builder = match "multi" {
7825            "multi" => local_var_req_builder.query(
7826                &local_var_str
7827                    .into_iter()
7828                    .map(|p| ("model__iew".to_owned(), p.to_string()))
7829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7830            ),
7831            _ => local_var_req_builder.query(&[(
7832                "model__iew",
7833                &local_var_str
7834                    .into_iter()
7835                    .map(|p| p.to_string())
7836                    .collect::<Vec<String>>()
7837                    .join(",")
7838                    .to_string(),
7839            )]),
7840        };
7841    }
7842    if let Some(ref local_var_str) = model__iregex {
7843        local_var_req_builder = match "multi" {
7844            "multi" => local_var_req_builder.query(
7845                &local_var_str
7846                    .into_iter()
7847                    .map(|p| ("model__iregex".to_owned(), p.to_string()))
7848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7849            ),
7850            _ => local_var_req_builder.query(&[(
7851                "model__iregex",
7852                &local_var_str
7853                    .into_iter()
7854                    .map(|p| p.to_string())
7855                    .collect::<Vec<String>>()
7856                    .join(",")
7857                    .to_string(),
7858            )]),
7859        };
7860    }
7861    if let Some(ref local_var_str) = model__isw {
7862        local_var_req_builder = match "multi" {
7863            "multi" => local_var_req_builder.query(
7864                &local_var_str
7865                    .into_iter()
7866                    .map(|p| ("model__isw".to_owned(), p.to_string()))
7867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7868            ),
7869            _ => local_var_req_builder.query(&[(
7870                "model__isw",
7871                &local_var_str
7872                    .into_iter()
7873                    .map(|p| p.to_string())
7874                    .collect::<Vec<String>>()
7875                    .join(",")
7876                    .to_string(),
7877            )]),
7878        };
7879    }
7880    if let Some(ref local_var_str) = model__n {
7881        local_var_req_builder = match "multi" {
7882            "multi" => local_var_req_builder.query(
7883                &local_var_str
7884                    .into_iter()
7885                    .map(|p| ("model__n".to_owned(), p.to_string()))
7886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7887            ),
7888            _ => local_var_req_builder.query(&[(
7889                "model__n",
7890                &local_var_str
7891                    .into_iter()
7892                    .map(|p| p.to_string())
7893                    .collect::<Vec<String>>()
7894                    .join(",")
7895                    .to_string(),
7896            )]),
7897        };
7898    }
7899    if let Some(ref local_var_str) = model__nic {
7900        local_var_req_builder = match "multi" {
7901            "multi" => local_var_req_builder.query(
7902                &local_var_str
7903                    .into_iter()
7904                    .map(|p| ("model__nic".to_owned(), p.to_string()))
7905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7906            ),
7907            _ => local_var_req_builder.query(&[(
7908                "model__nic",
7909                &local_var_str
7910                    .into_iter()
7911                    .map(|p| p.to_string())
7912                    .collect::<Vec<String>>()
7913                    .join(",")
7914                    .to_string(),
7915            )]),
7916        };
7917    }
7918    if let Some(ref local_var_str) = model__nie {
7919        local_var_req_builder = match "multi" {
7920            "multi" => local_var_req_builder.query(
7921                &local_var_str
7922                    .into_iter()
7923                    .map(|p| ("model__nie".to_owned(), p.to_string()))
7924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7925            ),
7926            _ => local_var_req_builder.query(&[(
7927                "model__nie",
7928                &local_var_str
7929                    .into_iter()
7930                    .map(|p| p.to_string())
7931                    .collect::<Vec<String>>()
7932                    .join(",")
7933                    .to_string(),
7934            )]),
7935        };
7936    }
7937    if let Some(ref local_var_str) = model__niew {
7938        local_var_req_builder = match "multi" {
7939            "multi" => local_var_req_builder.query(
7940                &local_var_str
7941                    .into_iter()
7942                    .map(|p| ("model__niew".to_owned(), p.to_string()))
7943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7944            ),
7945            _ => local_var_req_builder.query(&[(
7946                "model__niew",
7947                &local_var_str
7948                    .into_iter()
7949                    .map(|p| p.to_string())
7950                    .collect::<Vec<String>>()
7951                    .join(",")
7952                    .to_string(),
7953            )]),
7954        };
7955    }
7956    if let Some(ref local_var_str) = model__nisw {
7957        local_var_req_builder = match "multi" {
7958            "multi" => local_var_req_builder.query(
7959                &local_var_str
7960                    .into_iter()
7961                    .map(|p| ("model__nisw".to_owned(), p.to_string()))
7962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7963            ),
7964            _ => local_var_req_builder.query(&[(
7965                "model__nisw",
7966                &local_var_str
7967                    .into_iter()
7968                    .map(|p| p.to_string())
7969                    .collect::<Vec<String>>()
7970                    .join(",")
7971                    .to_string(),
7972            )]),
7973        };
7974    }
7975    if let Some(ref local_var_str) = model__regex {
7976        local_var_req_builder = match "multi" {
7977            "multi" => local_var_req_builder.query(
7978                &local_var_str
7979                    .into_iter()
7980                    .map(|p| ("model__regex".to_owned(), p.to_string()))
7981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7982            ),
7983            _ => local_var_req_builder.query(&[(
7984                "model__regex",
7985                &local_var_str
7986                    .into_iter()
7987                    .map(|p| p.to_string())
7988                    .collect::<Vec<String>>()
7989                    .join(",")
7990                    .to_string(),
7991            )]),
7992        };
7993    }
7994    if let Some(ref local_var_str) = offset {
7995        local_var_req_builder =
7996            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7997    }
7998    if let Some(ref local_var_str) = ordering {
7999        local_var_req_builder =
8000            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
8001    }
8002    if let Some(ref local_var_str) = public {
8003        local_var_req_builder =
8004            local_var_req_builder.query(&[("public", &local_var_str.to_string())]);
8005    }
8006    if let Some(ref local_var_str) = q {
8007        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8008    }
8009    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8010        local_var_req_builder =
8011            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8012    }
8013    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8014        let local_var_key = local_var_apikey.key.clone();
8015        let local_var_value = match local_var_apikey.prefix {
8016            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8017            None => local_var_key,
8018        };
8019        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8020    };
8021
8022    let local_var_req = local_var_req_builder.build()?;
8023    let local_var_resp = local_var_client.execute(local_var_req).await?;
8024
8025    let local_var_status = local_var_resp.status();
8026    let local_var_content = local_var_resp.text().await?;
8027
8028    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8029        serde_json::from_str(&local_var_content).map_err(Error::from)
8030    } else {
8031        let local_var_entity: Option<CoreObjectTypesListError> =
8032            serde_json::from_str(&local_var_content).ok();
8033        let local_var_error = ResponseContent {
8034            status: local_var_status,
8035            content: local_var_content,
8036            entity: local_var_entity,
8037        };
8038        Err(Error::ResponseError(local_var_error))
8039    }
8040}
8041
8042/// Read-only list of ObjectTypes.
8043pub async fn core_object_types_retrieve(
8044    configuration: &configuration::Configuration,
8045    id: i32,
8046) -> Result<crate::models::ObjectType, Error<CoreObjectTypesRetrieveError>> {
8047    let local_var_configuration = configuration;
8048
8049    let local_var_client = &local_var_configuration.client;
8050
8051    let local_var_uri_str = format!(
8052        "{}/api/core/object-types/{id}/",
8053        local_var_configuration.base_path,
8054        id = id
8055    );
8056    let mut local_var_req_builder =
8057        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8058
8059    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8060        local_var_req_builder =
8061            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8062    }
8063    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8064        let local_var_key = local_var_apikey.key.clone();
8065        let local_var_value = match local_var_apikey.prefix {
8066            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8067            None => local_var_key,
8068        };
8069        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8070    };
8071
8072    let local_var_req = local_var_req_builder.build()?;
8073    let local_var_resp = local_var_client.execute(local_var_req).await?;
8074
8075    let local_var_status = local_var_resp.status();
8076    let local_var_content = local_var_resp.text().await?;
8077
8078    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8079        serde_json::from_str(&local_var_content).map_err(Error::from)
8080    } else {
8081        let local_var_entity: Option<CoreObjectTypesRetrieveError> =
8082            serde_json::from_str(&local_var_content).ok();
8083        let local_var_error = ResponseContent {
8084            status: local_var_status,
8085            content: local_var_content,
8086            entity: local_var_entity,
8087        };
8088        Err(Error::ResponseError(local_var_error))
8089    }
8090}
netbox_openapi/apis/core_api.rs

netbox_openapi/apis/
core_api.rs
