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

netbox_openapi/apis/
core_api.rs
