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

netbox_openapi/apis/
core_api.rs
