netbox_openapi/apis/
plugins_api.rs

1/*
2 * NetBox REST API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 4.4.2-Docker-3.4.1 (4.4)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`plugins_branching_branch_events_list`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum PluginsBranchingBranchEventsListError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`plugins_branching_branch_events_retrieve`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum PluginsBranchingBranchEventsRetrieveError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`plugins_branching_branches_create`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum PluginsBranchingBranchesCreateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`plugins_branching_branches_destroy`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum PluginsBranchingBranchesDestroyError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`plugins_branching_branches_list`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum PluginsBranchingBranchesListError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`plugins_branching_branches_merge_create`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum PluginsBranchingBranchesMergeCreateError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`plugins_branching_branches_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum PluginsBranchingBranchesPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`plugins_branching_branches_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum PluginsBranchingBranchesRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`plugins_branching_branches_revert_create`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum PluginsBranchingBranchesRevertCreateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`plugins_branching_branches_sync_create`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum PluginsBranchingBranchesSyncCreateError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`plugins_branching_branches_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum PluginsBranchingBranchesUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`plugins_branching_changes_list`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum PluginsBranchingChangesListError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`plugins_branching_changes_retrieve`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum PluginsBranchingChangesRetrieveError {
104    UnknownValue(serde_json::Value),
105}
106
107/// Get a list of branch event objects.
108pub async fn plugins_branching_branch_events_list(
109    configuration: &configuration::Configuration,
110    id: Option<Vec<i32>>,
111    id__empty: Option<bool>,
112    id__gt: Option<Vec<i32>>,
113    id__gte: Option<Vec<i32>>,
114    id__lt: Option<Vec<i32>>,
115    id__lte: Option<Vec<i32>>,
116    id__n: Option<Vec<i32>>,
117    limit: Option<i32>,
118    offset: Option<i32>,
119    ordering: Option<&str>,
120    time: Option<Vec<String>>,
121    time__empty: Option<Vec<String>>,
122    time__gt: Option<Vec<String>>,
123    time__gte: Option<Vec<String>>,
124    time__lt: Option<Vec<String>>,
125    time__lte: Option<Vec<String>>,
126    time__n: Option<Vec<String>>,
127    r#type: Option<Vec<String>>,
128    type__empty: Option<bool>,
129    type__ic: Option<Vec<String>>,
130    type__ie: Option<Vec<String>>,
131    type__iew: Option<Vec<String>>,
132    type__iregex: Option<Vec<String>>,
133    type__isw: Option<Vec<String>>,
134    type__n: Option<Vec<String>>,
135    type__nic: Option<Vec<String>>,
136    type__nie: Option<Vec<String>>,
137    type__niew: Option<Vec<String>>,
138    type__nisw: Option<Vec<String>>,
139    type__regex: Option<Vec<String>>,
140) -> Result<crate::models::PaginatedBranchEventList, Error<PluginsBranchingBranchEventsListError>> {
141    let local_var_configuration = configuration;
142
143    let local_var_client = &local_var_configuration.client;
144
145    let local_var_uri_str = format!(
146        "{}/api/plugins/branching/branch-events/",
147        local_var_configuration.base_path
148    );
149    let mut local_var_req_builder =
150        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
151
152    if let Some(ref local_var_str) = id {
153        local_var_req_builder = match "multi" {
154            "multi" => local_var_req_builder.query(
155                &local_var_str
156                    .into_iter()
157                    .map(|p| ("id".to_owned(), p.to_string()))
158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
159            ),
160            _ => local_var_req_builder.query(&[(
161                "id",
162                &local_var_str
163                    .into_iter()
164                    .map(|p| p.to_string())
165                    .collect::<Vec<String>>()
166                    .join(",")
167                    .to_string(),
168            )]),
169        };
170    }
171    if let Some(ref local_var_str) = id__empty {
172        local_var_req_builder =
173            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
174    }
175    if let Some(ref local_var_str) = id__gt {
176        local_var_req_builder = match "multi" {
177            "multi" => local_var_req_builder.query(
178                &local_var_str
179                    .into_iter()
180                    .map(|p| ("id__gt".to_owned(), p.to_string()))
181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
182            ),
183            _ => local_var_req_builder.query(&[(
184                "id__gt",
185                &local_var_str
186                    .into_iter()
187                    .map(|p| p.to_string())
188                    .collect::<Vec<String>>()
189                    .join(",")
190                    .to_string(),
191            )]),
192        };
193    }
194    if let Some(ref local_var_str) = id__gte {
195        local_var_req_builder = match "multi" {
196            "multi" => local_var_req_builder.query(
197                &local_var_str
198                    .into_iter()
199                    .map(|p| ("id__gte".to_owned(), p.to_string()))
200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
201            ),
202            _ => local_var_req_builder.query(&[(
203                "id__gte",
204                &local_var_str
205                    .into_iter()
206                    .map(|p| p.to_string())
207                    .collect::<Vec<String>>()
208                    .join(",")
209                    .to_string(),
210            )]),
211        };
212    }
213    if let Some(ref local_var_str) = id__lt {
214        local_var_req_builder = match "multi" {
215            "multi" => local_var_req_builder.query(
216                &local_var_str
217                    .into_iter()
218                    .map(|p| ("id__lt".to_owned(), p.to_string()))
219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
220            ),
221            _ => local_var_req_builder.query(&[(
222                "id__lt",
223                &local_var_str
224                    .into_iter()
225                    .map(|p| p.to_string())
226                    .collect::<Vec<String>>()
227                    .join(",")
228                    .to_string(),
229            )]),
230        };
231    }
232    if let Some(ref local_var_str) = id__lte {
233        local_var_req_builder = match "multi" {
234            "multi" => local_var_req_builder.query(
235                &local_var_str
236                    .into_iter()
237                    .map(|p| ("id__lte".to_owned(), p.to_string()))
238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
239            ),
240            _ => local_var_req_builder.query(&[(
241                "id__lte",
242                &local_var_str
243                    .into_iter()
244                    .map(|p| p.to_string())
245                    .collect::<Vec<String>>()
246                    .join(",")
247                    .to_string(),
248            )]),
249        };
250    }
251    if let Some(ref local_var_str) = id__n {
252        local_var_req_builder = match "multi" {
253            "multi" => local_var_req_builder.query(
254                &local_var_str
255                    .into_iter()
256                    .map(|p| ("id__n".to_owned(), p.to_string()))
257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
258            ),
259            _ => local_var_req_builder.query(&[(
260                "id__n",
261                &local_var_str
262                    .into_iter()
263                    .map(|p| p.to_string())
264                    .collect::<Vec<String>>()
265                    .join(",")
266                    .to_string(),
267            )]),
268        };
269    }
270    if let Some(ref local_var_str) = limit {
271        local_var_req_builder =
272            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
273    }
274    if let Some(ref local_var_str) = offset {
275        local_var_req_builder =
276            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
277    }
278    if let Some(ref local_var_str) = ordering {
279        local_var_req_builder =
280            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
281    }
282    if let Some(ref local_var_str) = time {
283        local_var_req_builder = match "multi" {
284            "multi" => local_var_req_builder.query(
285                &local_var_str
286                    .into_iter()
287                    .map(|p| ("time".to_owned(), p.to_string()))
288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
289            ),
290            _ => local_var_req_builder.query(&[(
291                "time",
292                &local_var_str
293                    .into_iter()
294                    .map(|p| p.to_string())
295                    .collect::<Vec<String>>()
296                    .join(",")
297                    .to_string(),
298            )]),
299        };
300    }
301    if let Some(ref local_var_str) = time__empty {
302        local_var_req_builder = match "multi" {
303            "multi" => local_var_req_builder.query(
304                &local_var_str
305                    .into_iter()
306                    .map(|p| ("time__empty".to_owned(), p.to_string()))
307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
308            ),
309            _ => local_var_req_builder.query(&[(
310                "time__empty",
311                &local_var_str
312                    .into_iter()
313                    .map(|p| p.to_string())
314                    .collect::<Vec<String>>()
315                    .join(",")
316                    .to_string(),
317            )]),
318        };
319    }
320    if let Some(ref local_var_str) = time__gt {
321        local_var_req_builder = match "multi" {
322            "multi" => local_var_req_builder.query(
323                &local_var_str
324                    .into_iter()
325                    .map(|p| ("time__gt".to_owned(), p.to_string()))
326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
327            ),
328            _ => local_var_req_builder.query(&[(
329                "time__gt",
330                &local_var_str
331                    .into_iter()
332                    .map(|p| p.to_string())
333                    .collect::<Vec<String>>()
334                    .join(",")
335                    .to_string(),
336            )]),
337        };
338    }
339    if let Some(ref local_var_str) = time__gte {
340        local_var_req_builder = match "multi" {
341            "multi" => local_var_req_builder.query(
342                &local_var_str
343                    .into_iter()
344                    .map(|p| ("time__gte".to_owned(), p.to_string()))
345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
346            ),
347            _ => local_var_req_builder.query(&[(
348                "time__gte",
349                &local_var_str
350                    .into_iter()
351                    .map(|p| p.to_string())
352                    .collect::<Vec<String>>()
353                    .join(",")
354                    .to_string(),
355            )]),
356        };
357    }
358    if let Some(ref local_var_str) = time__lt {
359        local_var_req_builder = match "multi" {
360            "multi" => local_var_req_builder.query(
361                &local_var_str
362                    .into_iter()
363                    .map(|p| ("time__lt".to_owned(), p.to_string()))
364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
365            ),
366            _ => local_var_req_builder.query(&[(
367                "time__lt",
368                &local_var_str
369                    .into_iter()
370                    .map(|p| p.to_string())
371                    .collect::<Vec<String>>()
372                    .join(",")
373                    .to_string(),
374            )]),
375        };
376    }
377    if let Some(ref local_var_str) = time__lte {
378        local_var_req_builder = match "multi" {
379            "multi" => local_var_req_builder.query(
380                &local_var_str
381                    .into_iter()
382                    .map(|p| ("time__lte".to_owned(), p.to_string()))
383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
384            ),
385            _ => local_var_req_builder.query(&[(
386                "time__lte",
387                &local_var_str
388                    .into_iter()
389                    .map(|p| p.to_string())
390                    .collect::<Vec<String>>()
391                    .join(",")
392                    .to_string(),
393            )]),
394        };
395    }
396    if let Some(ref local_var_str) = time__n {
397        local_var_req_builder = match "multi" {
398            "multi" => local_var_req_builder.query(
399                &local_var_str
400                    .into_iter()
401                    .map(|p| ("time__n".to_owned(), p.to_string()))
402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
403            ),
404            _ => local_var_req_builder.query(&[(
405                "time__n",
406                &local_var_str
407                    .into_iter()
408                    .map(|p| p.to_string())
409                    .collect::<Vec<String>>()
410                    .join(",")
411                    .to_string(),
412            )]),
413        };
414    }
415    if let Some(ref local_var_str) = r#type {
416        local_var_req_builder = match "multi" {
417            "multi" => local_var_req_builder.query(
418                &local_var_str
419                    .into_iter()
420                    .map(|p| ("type".to_owned(), p.to_string()))
421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
422            ),
423            _ => local_var_req_builder.query(&[(
424                "type",
425                &local_var_str
426                    .into_iter()
427                    .map(|p| p.to_string())
428                    .collect::<Vec<String>>()
429                    .join(",")
430                    .to_string(),
431            )]),
432        };
433    }
434    if let Some(ref local_var_str) = type__empty {
435        local_var_req_builder =
436            local_var_req_builder.query(&[("type__empty", &local_var_str.to_string())]);
437    }
438    if let Some(ref local_var_str) = type__ic {
439        local_var_req_builder = match "multi" {
440            "multi" => local_var_req_builder.query(
441                &local_var_str
442                    .into_iter()
443                    .map(|p| ("type__ic".to_owned(), p.to_string()))
444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
445            ),
446            _ => local_var_req_builder.query(&[(
447                "type__ic",
448                &local_var_str
449                    .into_iter()
450                    .map(|p| p.to_string())
451                    .collect::<Vec<String>>()
452                    .join(",")
453                    .to_string(),
454            )]),
455        };
456    }
457    if let Some(ref local_var_str) = type__ie {
458        local_var_req_builder = match "multi" {
459            "multi" => local_var_req_builder.query(
460                &local_var_str
461                    .into_iter()
462                    .map(|p| ("type__ie".to_owned(), p.to_string()))
463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
464            ),
465            _ => local_var_req_builder.query(&[(
466                "type__ie",
467                &local_var_str
468                    .into_iter()
469                    .map(|p| p.to_string())
470                    .collect::<Vec<String>>()
471                    .join(",")
472                    .to_string(),
473            )]),
474        };
475    }
476    if let Some(ref local_var_str) = type__iew {
477        local_var_req_builder = match "multi" {
478            "multi" => local_var_req_builder.query(
479                &local_var_str
480                    .into_iter()
481                    .map(|p| ("type__iew".to_owned(), p.to_string()))
482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
483            ),
484            _ => local_var_req_builder.query(&[(
485                "type__iew",
486                &local_var_str
487                    .into_iter()
488                    .map(|p| p.to_string())
489                    .collect::<Vec<String>>()
490                    .join(",")
491                    .to_string(),
492            )]),
493        };
494    }
495    if let Some(ref local_var_str) = type__iregex {
496        local_var_req_builder = match "multi" {
497            "multi" => local_var_req_builder.query(
498                &local_var_str
499                    .into_iter()
500                    .map(|p| ("type__iregex".to_owned(), p.to_string()))
501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
502            ),
503            _ => local_var_req_builder.query(&[(
504                "type__iregex",
505                &local_var_str
506                    .into_iter()
507                    .map(|p| p.to_string())
508                    .collect::<Vec<String>>()
509                    .join(",")
510                    .to_string(),
511            )]),
512        };
513    }
514    if let Some(ref local_var_str) = type__isw {
515        local_var_req_builder = match "multi" {
516            "multi" => local_var_req_builder.query(
517                &local_var_str
518                    .into_iter()
519                    .map(|p| ("type__isw".to_owned(), p.to_string()))
520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
521            ),
522            _ => local_var_req_builder.query(&[(
523                "type__isw",
524                &local_var_str
525                    .into_iter()
526                    .map(|p| p.to_string())
527                    .collect::<Vec<String>>()
528                    .join(",")
529                    .to_string(),
530            )]),
531        };
532    }
533    if let Some(ref local_var_str) = type__n {
534        local_var_req_builder = match "multi" {
535            "multi" => local_var_req_builder.query(
536                &local_var_str
537                    .into_iter()
538                    .map(|p| ("type__n".to_owned(), p.to_string()))
539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
540            ),
541            _ => local_var_req_builder.query(&[(
542                "type__n",
543                &local_var_str
544                    .into_iter()
545                    .map(|p| p.to_string())
546                    .collect::<Vec<String>>()
547                    .join(",")
548                    .to_string(),
549            )]),
550        };
551    }
552    if let Some(ref local_var_str) = type__nic {
553        local_var_req_builder = match "multi" {
554            "multi" => local_var_req_builder.query(
555                &local_var_str
556                    .into_iter()
557                    .map(|p| ("type__nic".to_owned(), p.to_string()))
558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
559            ),
560            _ => local_var_req_builder.query(&[(
561                "type__nic",
562                &local_var_str
563                    .into_iter()
564                    .map(|p| p.to_string())
565                    .collect::<Vec<String>>()
566                    .join(",")
567                    .to_string(),
568            )]),
569        };
570    }
571    if let Some(ref local_var_str) = type__nie {
572        local_var_req_builder = match "multi" {
573            "multi" => local_var_req_builder.query(
574                &local_var_str
575                    .into_iter()
576                    .map(|p| ("type__nie".to_owned(), p.to_string()))
577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
578            ),
579            _ => local_var_req_builder.query(&[(
580                "type__nie",
581                &local_var_str
582                    .into_iter()
583                    .map(|p| p.to_string())
584                    .collect::<Vec<String>>()
585                    .join(",")
586                    .to_string(),
587            )]),
588        };
589    }
590    if let Some(ref local_var_str) = type__niew {
591        local_var_req_builder = match "multi" {
592            "multi" => local_var_req_builder.query(
593                &local_var_str
594                    .into_iter()
595                    .map(|p| ("type__niew".to_owned(), p.to_string()))
596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
597            ),
598            _ => local_var_req_builder.query(&[(
599                "type__niew",
600                &local_var_str
601                    .into_iter()
602                    .map(|p| p.to_string())
603                    .collect::<Vec<String>>()
604                    .join(",")
605                    .to_string(),
606            )]),
607        };
608    }
609    if let Some(ref local_var_str) = type__nisw {
610        local_var_req_builder = match "multi" {
611            "multi" => local_var_req_builder.query(
612                &local_var_str
613                    .into_iter()
614                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
616            ),
617            _ => local_var_req_builder.query(&[(
618                "type__nisw",
619                &local_var_str
620                    .into_iter()
621                    .map(|p| p.to_string())
622                    .collect::<Vec<String>>()
623                    .join(",")
624                    .to_string(),
625            )]),
626        };
627    }
628    if let Some(ref local_var_str) = type__regex {
629        local_var_req_builder = match "multi" {
630            "multi" => local_var_req_builder.query(
631                &local_var_str
632                    .into_iter()
633                    .map(|p| ("type__regex".to_owned(), p.to_string()))
634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
635            ),
636            _ => local_var_req_builder.query(&[(
637                "type__regex",
638                &local_var_str
639                    .into_iter()
640                    .map(|p| p.to_string())
641                    .collect::<Vec<String>>()
642                    .join(",")
643                    .to_string(),
644            )]),
645        };
646    }
647    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
648        local_var_req_builder =
649            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
650    }
651    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
652        let local_var_key = local_var_apikey.key.clone();
653        let local_var_value = match local_var_apikey.prefix {
654            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
655            None => local_var_key,
656        };
657        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
658    };
659
660    let local_var_req = local_var_req_builder.build()?;
661    let local_var_resp = local_var_client.execute(local_var_req).await?;
662
663    let local_var_status = local_var_resp.status();
664    let local_var_content = local_var_resp.text().await?;
665
666    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
667        serde_json::from_str(&local_var_content).map_err(Error::from)
668    } else {
669        let local_var_entity: Option<PluginsBranchingBranchEventsListError> =
670            serde_json::from_str(&local_var_content).ok();
671        let local_var_error = ResponseContent {
672            status: local_var_status,
673            content: local_var_content,
674            entity: local_var_entity,
675        };
676        Err(Error::ResponseError(local_var_error))
677    }
678}
679
680/// Get a branch event object.
681pub async fn plugins_branching_branch_events_retrieve(
682    configuration: &configuration::Configuration,
683    id: i32,
684) -> Result<crate::models::BranchEvent, Error<PluginsBranchingBranchEventsRetrieveError>> {
685    let local_var_configuration = configuration;
686
687    let local_var_client = &local_var_configuration.client;
688
689    let local_var_uri_str = format!(
690        "{}/api/plugins/branching/branch-events/{id}/",
691        local_var_configuration.base_path,
692        id = id
693    );
694    let mut local_var_req_builder =
695        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
696
697    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
698        local_var_req_builder =
699            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
700    }
701    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
702        let local_var_key = local_var_apikey.key.clone();
703        let local_var_value = match local_var_apikey.prefix {
704            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
705            None => local_var_key,
706        };
707        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
708    };
709
710    let local_var_req = local_var_req_builder.build()?;
711    let local_var_resp = local_var_client.execute(local_var_req).await?;
712
713    let local_var_status = local_var_resp.status();
714    let local_var_content = local_var_resp.text().await?;
715
716    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
717        serde_json::from_str(&local_var_content).map_err(Error::from)
718    } else {
719        let local_var_entity: Option<PluginsBranchingBranchEventsRetrieveError> =
720            serde_json::from_str(&local_var_content).ok();
721        let local_var_error = ResponseContent {
722            status: local_var_status,
723            content: local_var_content,
724            entity: local_var_entity,
725        };
726        Err(Error::ResponseError(local_var_error))
727    }
728}
729
730/// Post a list of branch objects.
731pub async fn plugins_branching_branches_create(
732    configuration: &configuration::Configuration,
733    writable_branch_request: crate::models::WritableBranchRequest,
734) -> Result<crate::models::Branch, Error<PluginsBranchingBranchesCreateError>> {
735    let local_var_configuration = configuration;
736
737    let local_var_client = &local_var_configuration.client;
738
739    let local_var_uri_str = format!(
740        "{}/api/plugins/branching/branches/",
741        local_var_configuration.base_path
742    );
743    let mut local_var_req_builder =
744        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
745
746    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
747        local_var_req_builder =
748            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
749    }
750    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
751        let local_var_key = local_var_apikey.key.clone();
752        let local_var_value = match local_var_apikey.prefix {
753            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
754            None => local_var_key,
755        };
756        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
757    };
758    local_var_req_builder = local_var_req_builder.json(&writable_branch_request);
759
760    let local_var_req = local_var_req_builder.build()?;
761    let local_var_resp = local_var_client.execute(local_var_req).await?;
762
763    let local_var_status = local_var_resp.status();
764    let local_var_content = local_var_resp.text().await?;
765
766    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
767        serde_json::from_str(&local_var_content).map_err(Error::from)
768    } else {
769        let local_var_entity: Option<PluginsBranchingBranchesCreateError> =
770            serde_json::from_str(&local_var_content).ok();
771        let local_var_error = ResponseContent {
772            status: local_var_status,
773            content: local_var_content,
774            entity: local_var_entity,
775        };
776        Err(Error::ResponseError(local_var_error))
777    }
778}
779
780/// Delete a branch object.
781pub async fn plugins_branching_branches_destroy(
782    configuration: &configuration::Configuration,
783    id: i32,
784) -> Result<(), Error<PluginsBranchingBranchesDestroyError>> {
785    let local_var_configuration = configuration;
786
787    let local_var_client = &local_var_configuration.client;
788
789    let local_var_uri_str = format!(
790        "{}/api/plugins/branching/branches/{id}/",
791        local_var_configuration.base_path,
792        id = id
793    );
794    let mut local_var_req_builder =
795        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
796
797    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
798        local_var_req_builder =
799            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
800    }
801    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
802        let local_var_key = local_var_apikey.key.clone();
803        let local_var_value = match local_var_apikey.prefix {
804            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
805            None => local_var_key,
806        };
807        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
808    };
809
810    let local_var_req = local_var_req_builder.build()?;
811    let local_var_resp = local_var_client.execute(local_var_req).await?;
812
813    let local_var_status = local_var_resp.status();
814    let local_var_content = local_var_resp.text().await?;
815
816    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
817        Ok(())
818    } else {
819        let local_var_entity: Option<PluginsBranchingBranchesDestroyError> =
820            serde_json::from_str(&local_var_content).ok();
821        let local_var_error = ResponseContent {
822            status: local_var_status,
823            content: local_var_content,
824            entity: local_var_entity,
825        };
826        Err(Error::ResponseError(local_var_error))
827    }
828}
829
830/// Get a list of branch objects.
831pub async fn plugins_branching_branches_list(
832    configuration: &configuration::Configuration,
833    created: Option<Vec<String>>,
834    created__empty: Option<Vec<String>>,
835    created__gt: Option<Vec<String>>,
836    created__gte: Option<Vec<String>>,
837    created__lt: Option<Vec<String>>,
838    created__lte: Option<Vec<String>>,
839    created__n: Option<Vec<String>>,
840    created_by_request: Option<&str>,
841    description: Option<Vec<String>>,
842    description__empty: Option<bool>,
843    description__ic: Option<Vec<String>>,
844    description__ie: Option<Vec<String>>,
845    description__iew: Option<Vec<String>>,
846    description__iregex: Option<Vec<String>>,
847    description__isw: Option<Vec<String>>,
848    description__n: Option<Vec<String>>,
849    description__nic: Option<Vec<String>>,
850    description__nie: Option<Vec<String>>,
851    description__niew: Option<Vec<String>>,
852    description__nisw: Option<Vec<String>>,
853    description__regex: Option<Vec<String>>,
854    id: Option<Vec<i32>>,
855    id__empty: Option<bool>,
856    id__gt: Option<Vec<i32>>,
857    id__gte: Option<Vec<i32>>,
858    id__lt: Option<Vec<i32>>,
859    id__lte: Option<Vec<i32>>,
860    id__n: Option<Vec<i32>>,
861    last_sync: Option<Vec<String>>,
862    last_sync__empty: Option<Vec<String>>,
863    last_sync__gt: Option<Vec<String>>,
864    last_sync__gte: Option<Vec<String>>,
865    last_sync__lt: Option<Vec<String>>,
866    last_sync__lte: Option<Vec<String>>,
867    last_sync__n: Option<Vec<String>>,
868    last_updated: Option<Vec<String>>,
869    last_updated__empty: Option<Vec<String>>,
870    last_updated__gt: Option<Vec<String>>,
871    last_updated__gte: Option<Vec<String>>,
872    last_updated__lt: Option<Vec<String>>,
873    last_updated__lte: Option<Vec<String>>,
874    last_updated__n: Option<Vec<String>>,
875    limit: Option<i32>,
876    modified_by_request: Option<&str>,
877    name: Option<Vec<String>>,
878    name__empty: Option<bool>,
879    name__ic: Option<Vec<String>>,
880    name__ie: Option<Vec<String>>,
881    name__iew: Option<Vec<String>>,
882    name__iregex: Option<Vec<String>>,
883    name__isw: Option<Vec<String>>,
884    name__n: Option<Vec<String>>,
885    name__nic: Option<Vec<String>>,
886    name__nie: Option<Vec<String>>,
887    name__niew: Option<Vec<String>>,
888    name__nisw: Option<Vec<String>>,
889    name__regex: Option<Vec<String>>,
890    offset: Option<i32>,
891    ordering: Option<&str>,
892    q: Option<&str>,
893    status: Option<Vec<String>>,
894    status__empty: Option<bool>,
895    status__ic: Option<Vec<String>>,
896    status__ie: Option<Vec<String>>,
897    status__iew: Option<Vec<String>>,
898    status__iregex: Option<Vec<String>>,
899    status__isw: Option<Vec<String>>,
900    status__n: Option<Vec<String>>,
901    status__nic: Option<Vec<String>>,
902    status__nie: Option<Vec<String>>,
903    status__niew: Option<Vec<String>>,
904    status__nisw: Option<Vec<String>>,
905    status__regex: Option<Vec<String>>,
906    tag: Option<Vec<String>>,
907    tag__n: Option<Vec<String>>,
908    tag_id: Option<Vec<i32>>,
909    tag_id__n: Option<Vec<i32>>,
910    updated_by_request: Option<&str>,
911) -> Result<crate::models::PaginatedBranchList, Error<PluginsBranchingBranchesListError>> {
912    let local_var_configuration = configuration;
913
914    let local_var_client = &local_var_configuration.client;
915
916    let local_var_uri_str = format!(
917        "{}/api/plugins/branching/branches/",
918        local_var_configuration.base_path
919    );
920    let mut local_var_req_builder =
921        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
922
923    if let Some(ref local_var_str) = created {
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".to_owned(), p.to_string()))
929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
930            ),
931            _ => local_var_req_builder.query(&[(
932                "created",
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__empty {
943        local_var_req_builder = match "multi" {
944            "multi" => local_var_req_builder.query(
945                &local_var_str
946                    .into_iter()
947                    .map(|p| ("created__empty".to_owned(), p.to_string()))
948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
949            ),
950            _ => local_var_req_builder.query(&[(
951                "created__empty",
952                &local_var_str
953                    .into_iter()
954                    .map(|p| p.to_string())
955                    .collect::<Vec<String>>()
956                    .join(",")
957                    .to_string(),
958            )]),
959        };
960    }
961    if let Some(ref local_var_str) = created__gt {
962        local_var_req_builder = match "multi" {
963            "multi" => local_var_req_builder.query(
964                &local_var_str
965                    .into_iter()
966                    .map(|p| ("created__gt".to_owned(), p.to_string()))
967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
968            ),
969            _ => local_var_req_builder.query(&[(
970                "created__gt",
971                &local_var_str
972                    .into_iter()
973                    .map(|p| p.to_string())
974                    .collect::<Vec<String>>()
975                    .join(",")
976                    .to_string(),
977            )]),
978        };
979    }
980    if let Some(ref local_var_str) = created__gte {
981        local_var_req_builder = match "multi" {
982            "multi" => local_var_req_builder.query(
983                &local_var_str
984                    .into_iter()
985                    .map(|p| ("created__gte".to_owned(), p.to_string()))
986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
987            ),
988            _ => local_var_req_builder.query(&[(
989                "created__gte",
990                &local_var_str
991                    .into_iter()
992                    .map(|p| p.to_string())
993                    .collect::<Vec<String>>()
994                    .join(",")
995                    .to_string(),
996            )]),
997        };
998    }
999    if let Some(ref local_var_str) = created__lt {
1000        local_var_req_builder = match "multi" {
1001            "multi" => local_var_req_builder.query(
1002                &local_var_str
1003                    .into_iter()
1004                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1006            ),
1007            _ => local_var_req_builder.query(&[(
1008                "created__lt",
1009                &local_var_str
1010                    .into_iter()
1011                    .map(|p| p.to_string())
1012                    .collect::<Vec<String>>()
1013                    .join(",")
1014                    .to_string(),
1015            )]),
1016        };
1017    }
1018    if let Some(ref local_var_str) = created__lte {
1019        local_var_req_builder = match "multi" {
1020            "multi" => local_var_req_builder.query(
1021                &local_var_str
1022                    .into_iter()
1023                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1025            ),
1026            _ => local_var_req_builder.query(&[(
1027                "created__lte",
1028                &local_var_str
1029                    .into_iter()
1030                    .map(|p| p.to_string())
1031                    .collect::<Vec<String>>()
1032                    .join(",")
1033                    .to_string(),
1034            )]),
1035        };
1036    }
1037    if let Some(ref local_var_str) = created__n {
1038        local_var_req_builder = match "multi" {
1039            "multi" => local_var_req_builder.query(
1040                &local_var_str
1041                    .into_iter()
1042                    .map(|p| ("created__n".to_owned(), p.to_string()))
1043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1044            ),
1045            _ => local_var_req_builder.query(&[(
1046                "created__n",
1047                &local_var_str
1048                    .into_iter()
1049                    .map(|p| p.to_string())
1050                    .collect::<Vec<String>>()
1051                    .join(",")
1052                    .to_string(),
1053            )]),
1054        };
1055    }
1056    if let Some(ref local_var_str) = created_by_request {
1057        local_var_req_builder =
1058            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1059    }
1060    if let Some(ref local_var_str) = description {
1061        local_var_req_builder = match "multi" {
1062            "multi" => local_var_req_builder.query(
1063                &local_var_str
1064                    .into_iter()
1065                    .map(|p| ("description".to_owned(), p.to_string()))
1066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1067            ),
1068            _ => local_var_req_builder.query(&[(
1069                "description",
1070                &local_var_str
1071                    .into_iter()
1072                    .map(|p| p.to_string())
1073                    .collect::<Vec<String>>()
1074                    .join(",")
1075                    .to_string(),
1076            )]),
1077        };
1078    }
1079    if let Some(ref local_var_str) = description__empty {
1080        local_var_req_builder =
1081            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1082    }
1083    if let Some(ref local_var_str) = description__ic {
1084        local_var_req_builder = match "multi" {
1085            "multi" => local_var_req_builder.query(
1086                &local_var_str
1087                    .into_iter()
1088                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1090            ),
1091            _ => local_var_req_builder.query(&[(
1092                "description__ic",
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) = description__ie {
1103        local_var_req_builder = match "multi" {
1104            "multi" => local_var_req_builder.query(
1105                &local_var_str
1106                    .into_iter()
1107                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1109            ),
1110            _ => local_var_req_builder.query(&[(
1111                "description__ie",
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) = description__iew {
1122        local_var_req_builder = match "multi" {
1123            "multi" => local_var_req_builder.query(
1124                &local_var_str
1125                    .into_iter()
1126                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1128            ),
1129            _ => local_var_req_builder.query(&[(
1130                "description__iew",
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) = description__iregex {
1141        local_var_req_builder = match "multi" {
1142            "multi" => local_var_req_builder.query(
1143                &local_var_str
1144                    .into_iter()
1145                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1147            ),
1148            _ => local_var_req_builder.query(&[(
1149                "description__iregex",
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) = description__isw {
1160        local_var_req_builder = match "multi" {
1161            "multi" => local_var_req_builder.query(
1162                &local_var_str
1163                    .into_iter()
1164                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1166            ),
1167            _ => local_var_req_builder.query(&[(
1168                "description__isw",
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) = description__n {
1179        local_var_req_builder = match "multi" {
1180            "multi" => local_var_req_builder.query(
1181                &local_var_str
1182                    .into_iter()
1183                    .map(|p| ("description__n".to_owned(), p.to_string()))
1184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1185            ),
1186            _ => local_var_req_builder.query(&[(
1187                "description__n",
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) = description__nic {
1198        local_var_req_builder = match "multi" {
1199            "multi" => local_var_req_builder.query(
1200                &local_var_str
1201                    .into_iter()
1202                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1204            ),
1205            _ => local_var_req_builder.query(&[(
1206                "description__nic",
1207                &local_var_str
1208                    .into_iter()
1209                    .map(|p| p.to_string())
1210                    .collect::<Vec<String>>()
1211                    .join(",")
1212                    .to_string(),
1213            )]),
1214        };
1215    }
1216    if let Some(ref local_var_str) = description__nie {
1217        local_var_req_builder = match "multi" {
1218            "multi" => local_var_req_builder.query(
1219                &local_var_str
1220                    .into_iter()
1221                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1223            ),
1224            _ => local_var_req_builder.query(&[(
1225                "description__nie",
1226                &local_var_str
1227                    .into_iter()
1228                    .map(|p| p.to_string())
1229                    .collect::<Vec<String>>()
1230                    .join(",")
1231                    .to_string(),
1232            )]),
1233        };
1234    }
1235    if let Some(ref local_var_str) = description__niew {
1236        local_var_req_builder = match "multi" {
1237            "multi" => local_var_req_builder.query(
1238                &local_var_str
1239                    .into_iter()
1240                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1242            ),
1243            _ => local_var_req_builder.query(&[(
1244                "description__niew",
1245                &local_var_str
1246                    .into_iter()
1247                    .map(|p| p.to_string())
1248                    .collect::<Vec<String>>()
1249                    .join(",")
1250                    .to_string(),
1251            )]),
1252        };
1253    }
1254    if let Some(ref local_var_str) = description__nisw {
1255        local_var_req_builder = match "multi" {
1256            "multi" => local_var_req_builder.query(
1257                &local_var_str
1258                    .into_iter()
1259                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1261            ),
1262            _ => local_var_req_builder.query(&[(
1263                "description__nisw",
1264                &local_var_str
1265                    .into_iter()
1266                    .map(|p| p.to_string())
1267                    .collect::<Vec<String>>()
1268                    .join(",")
1269                    .to_string(),
1270            )]),
1271        };
1272    }
1273    if let Some(ref local_var_str) = description__regex {
1274        local_var_req_builder = match "multi" {
1275            "multi" => local_var_req_builder.query(
1276                &local_var_str
1277                    .into_iter()
1278                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1280            ),
1281            _ => local_var_req_builder.query(&[(
1282                "description__regex",
1283                &local_var_str
1284                    .into_iter()
1285                    .map(|p| p.to_string())
1286                    .collect::<Vec<String>>()
1287                    .join(",")
1288                    .to_string(),
1289            )]),
1290        };
1291    }
1292    if let Some(ref local_var_str) = id {
1293        local_var_req_builder = match "multi" {
1294            "multi" => local_var_req_builder.query(
1295                &local_var_str
1296                    .into_iter()
1297                    .map(|p| ("id".to_owned(), p.to_string()))
1298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1299            ),
1300            _ => local_var_req_builder.query(&[(
1301                "id",
1302                &local_var_str
1303                    .into_iter()
1304                    .map(|p| p.to_string())
1305                    .collect::<Vec<String>>()
1306                    .join(",")
1307                    .to_string(),
1308            )]),
1309        };
1310    }
1311    if let Some(ref local_var_str) = id__empty {
1312        local_var_req_builder =
1313            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1314    }
1315    if let Some(ref local_var_str) = id__gt {
1316        local_var_req_builder = match "multi" {
1317            "multi" => local_var_req_builder.query(
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1322            ),
1323            _ => local_var_req_builder.query(&[(
1324                "id__gt",
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) = id__gte {
1335        local_var_req_builder = match "multi" {
1336            "multi" => local_var_req_builder.query(
1337                &local_var_str
1338                    .into_iter()
1339                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1341            ),
1342            _ => local_var_req_builder.query(&[(
1343                "id__gte",
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) = id__lt {
1354        local_var_req_builder = match "multi" {
1355            "multi" => local_var_req_builder.query(
1356                &local_var_str
1357                    .into_iter()
1358                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1360            ),
1361            _ => local_var_req_builder.query(&[(
1362                "id__lt",
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) = id__lte {
1373        local_var_req_builder = match "multi" {
1374            "multi" => local_var_req_builder.query(
1375                &local_var_str
1376                    .into_iter()
1377                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1379            ),
1380            _ => local_var_req_builder.query(&[(
1381                "id__lte",
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) = id__n {
1392        local_var_req_builder = match "multi" {
1393            "multi" => local_var_req_builder.query(
1394                &local_var_str
1395                    .into_iter()
1396                    .map(|p| ("id__n".to_owned(), p.to_string()))
1397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1398            ),
1399            _ => local_var_req_builder.query(&[(
1400                "id__n",
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_sync {
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_sync".to_owned(), p.to_string()))
1416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1417            ),
1418            _ => local_var_req_builder.query(&[(
1419                "last_sync",
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) = last_sync__empty {
1430        local_var_req_builder = match "multi" {
1431            "multi" => local_var_req_builder.query(
1432                &local_var_str
1433                    .into_iter()
1434                    .map(|p| ("last_sync__empty".to_owned(), p.to_string()))
1435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1436            ),
1437            _ => local_var_req_builder.query(&[(
1438                "last_sync__empty",
1439                &local_var_str
1440                    .into_iter()
1441                    .map(|p| p.to_string())
1442                    .collect::<Vec<String>>()
1443                    .join(",")
1444                    .to_string(),
1445            )]),
1446        };
1447    }
1448    if let Some(ref local_var_str) = last_sync__gt {
1449        local_var_req_builder = match "multi" {
1450            "multi" => local_var_req_builder.query(
1451                &local_var_str
1452                    .into_iter()
1453                    .map(|p| ("last_sync__gt".to_owned(), p.to_string()))
1454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1455            ),
1456            _ => local_var_req_builder.query(&[(
1457                "last_sync__gt",
1458                &local_var_str
1459                    .into_iter()
1460                    .map(|p| p.to_string())
1461                    .collect::<Vec<String>>()
1462                    .join(",")
1463                    .to_string(),
1464            )]),
1465        };
1466    }
1467    if let Some(ref local_var_str) = last_sync__gte {
1468        local_var_req_builder = match "multi" {
1469            "multi" => local_var_req_builder.query(
1470                &local_var_str
1471                    .into_iter()
1472                    .map(|p| ("last_sync__gte".to_owned(), p.to_string()))
1473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1474            ),
1475            _ => local_var_req_builder.query(&[(
1476                "last_sync__gte",
1477                &local_var_str
1478                    .into_iter()
1479                    .map(|p| p.to_string())
1480                    .collect::<Vec<String>>()
1481                    .join(",")
1482                    .to_string(),
1483            )]),
1484        };
1485    }
1486    if let Some(ref local_var_str) = last_sync__lt {
1487        local_var_req_builder = match "multi" {
1488            "multi" => local_var_req_builder.query(
1489                &local_var_str
1490                    .into_iter()
1491                    .map(|p| ("last_sync__lt".to_owned(), p.to_string()))
1492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1493            ),
1494            _ => local_var_req_builder.query(&[(
1495                "last_sync__lt",
1496                &local_var_str
1497                    .into_iter()
1498                    .map(|p| p.to_string())
1499                    .collect::<Vec<String>>()
1500                    .join(",")
1501                    .to_string(),
1502            )]),
1503        };
1504    }
1505    if let Some(ref local_var_str) = last_sync__lte {
1506        local_var_req_builder = match "multi" {
1507            "multi" => local_var_req_builder.query(
1508                &local_var_str
1509                    .into_iter()
1510                    .map(|p| ("last_sync__lte".to_owned(), p.to_string()))
1511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1512            ),
1513            _ => local_var_req_builder.query(&[(
1514                "last_sync__lte",
1515                &local_var_str
1516                    .into_iter()
1517                    .map(|p| p.to_string())
1518                    .collect::<Vec<String>>()
1519                    .join(",")
1520                    .to_string(),
1521            )]),
1522        };
1523    }
1524    if let Some(ref local_var_str) = last_sync__n {
1525        local_var_req_builder = match "multi" {
1526            "multi" => local_var_req_builder.query(
1527                &local_var_str
1528                    .into_iter()
1529                    .map(|p| ("last_sync__n".to_owned(), p.to_string()))
1530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1531            ),
1532            _ => local_var_req_builder.query(&[(
1533                "last_sync__n",
1534                &local_var_str
1535                    .into_iter()
1536                    .map(|p| p.to_string())
1537                    .collect::<Vec<String>>()
1538                    .join(",")
1539                    .to_string(),
1540            )]),
1541        };
1542    }
1543    if let Some(ref local_var_str) = last_updated {
1544        local_var_req_builder = match "multi" {
1545            "multi" => local_var_req_builder.query(
1546                &local_var_str
1547                    .into_iter()
1548                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1550            ),
1551            _ => local_var_req_builder.query(&[(
1552                "last_updated",
1553                &local_var_str
1554                    .into_iter()
1555                    .map(|p| p.to_string())
1556                    .collect::<Vec<String>>()
1557                    .join(",")
1558                    .to_string(),
1559            )]),
1560        };
1561    }
1562    if let Some(ref local_var_str) = last_updated__empty {
1563        local_var_req_builder = match "multi" {
1564            "multi" => local_var_req_builder.query(
1565                &local_var_str
1566                    .into_iter()
1567                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1569            ),
1570            _ => local_var_req_builder.query(&[(
1571                "last_updated__empty",
1572                &local_var_str
1573                    .into_iter()
1574                    .map(|p| p.to_string())
1575                    .collect::<Vec<String>>()
1576                    .join(",")
1577                    .to_string(),
1578            )]),
1579        };
1580    }
1581    if let Some(ref local_var_str) = last_updated__gt {
1582        local_var_req_builder = match "multi" {
1583            "multi" => local_var_req_builder.query(
1584                &local_var_str
1585                    .into_iter()
1586                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1588            ),
1589            _ => local_var_req_builder.query(&[(
1590                "last_updated__gt",
1591                &local_var_str
1592                    .into_iter()
1593                    .map(|p| p.to_string())
1594                    .collect::<Vec<String>>()
1595                    .join(",")
1596                    .to_string(),
1597            )]),
1598        };
1599    }
1600    if let Some(ref local_var_str) = last_updated__gte {
1601        local_var_req_builder = match "multi" {
1602            "multi" => local_var_req_builder.query(
1603                &local_var_str
1604                    .into_iter()
1605                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1607            ),
1608            _ => local_var_req_builder.query(&[(
1609                "last_updated__gte",
1610                &local_var_str
1611                    .into_iter()
1612                    .map(|p| p.to_string())
1613                    .collect::<Vec<String>>()
1614                    .join(",")
1615                    .to_string(),
1616            )]),
1617        };
1618    }
1619    if let Some(ref local_var_str) = last_updated__lt {
1620        local_var_req_builder = match "multi" {
1621            "multi" => local_var_req_builder.query(
1622                &local_var_str
1623                    .into_iter()
1624                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1626            ),
1627            _ => local_var_req_builder.query(&[(
1628                "last_updated__lt",
1629                &local_var_str
1630                    .into_iter()
1631                    .map(|p| p.to_string())
1632                    .collect::<Vec<String>>()
1633                    .join(",")
1634                    .to_string(),
1635            )]),
1636        };
1637    }
1638    if let Some(ref local_var_str) = last_updated__lte {
1639        local_var_req_builder = match "multi" {
1640            "multi" => local_var_req_builder.query(
1641                &local_var_str
1642                    .into_iter()
1643                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1645            ),
1646            _ => local_var_req_builder.query(&[(
1647                "last_updated__lte",
1648                &local_var_str
1649                    .into_iter()
1650                    .map(|p| p.to_string())
1651                    .collect::<Vec<String>>()
1652                    .join(",")
1653                    .to_string(),
1654            )]),
1655        };
1656    }
1657    if let Some(ref local_var_str) = last_updated__n {
1658        local_var_req_builder = match "multi" {
1659            "multi" => local_var_req_builder.query(
1660                &local_var_str
1661                    .into_iter()
1662                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1664            ),
1665            _ => local_var_req_builder.query(&[(
1666                "last_updated__n",
1667                &local_var_str
1668                    .into_iter()
1669                    .map(|p| p.to_string())
1670                    .collect::<Vec<String>>()
1671                    .join(",")
1672                    .to_string(),
1673            )]),
1674        };
1675    }
1676    if let Some(ref local_var_str) = limit {
1677        local_var_req_builder =
1678            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1679    }
1680    if let Some(ref local_var_str) = modified_by_request {
1681        local_var_req_builder =
1682            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1683    }
1684    if let Some(ref local_var_str) = name {
1685        local_var_req_builder = match "multi" {
1686            "multi" => local_var_req_builder.query(
1687                &local_var_str
1688                    .into_iter()
1689                    .map(|p| ("name".to_owned(), p.to_string()))
1690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1691            ),
1692            _ => local_var_req_builder.query(&[(
1693                "name",
1694                &local_var_str
1695                    .into_iter()
1696                    .map(|p| p.to_string())
1697                    .collect::<Vec<String>>()
1698                    .join(",")
1699                    .to_string(),
1700            )]),
1701        };
1702    }
1703    if let Some(ref local_var_str) = name__empty {
1704        local_var_req_builder =
1705            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1706    }
1707    if let Some(ref local_var_str) = name__ic {
1708        local_var_req_builder = match "multi" {
1709            "multi" => local_var_req_builder.query(
1710                &local_var_str
1711                    .into_iter()
1712                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1714            ),
1715            _ => local_var_req_builder.query(&[(
1716                "name__ic",
1717                &local_var_str
1718                    .into_iter()
1719                    .map(|p| p.to_string())
1720                    .collect::<Vec<String>>()
1721                    .join(",")
1722                    .to_string(),
1723            )]),
1724        };
1725    }
1726    if let Some(ref local_var_str) = name__ie {
1727        local_var_req_builder = match "multi" {
1728            "multi" => local_var_req_builder.query(
1729                &local_var_str
1730                    .into_iter()
1731                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1733            ),
1734            _ => local_var_req_builder.query(&[(
1735                "name__ie",
1736                &local_var_str
1737                    .into_iter()
1738                    .map(|p| p.to_string())
1739                    .collect::<Vec<String>>()
1740                    .join(",")
1741                    .to_string(),
1742            )]),
1743        };
1744    }
1745    if let Some(ref local_var_str) = name__iew {
1746        local_var_req_builder = match "multi" {
1747            "multi" => local_var_req_builder.query(
1748                &local_var_str
1749                    .into_iter()
1750                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1752            ),
1753            _ => local_var_req_builder.query(&[(
1754                "name__iew",
1755                &local_var_str
1756                    .into_iter()
1757                    .map(|p| p.to_string())
1758                    .collect::<Vec<String>>()
1759                    .join(",")
1760                    .to_string(),
1761            )]),
1762        };
1763    }
1764    if let Some(ref local_var_str) = name__iregex {
1765        local_var_req_builder = match "multi" {
1766            "multi" => local_var_req_builder.query(
1767                &local_var_str
1768                    .into_iter()
1769                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
1770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1771            ),
1772            _ => local_var_req_builder.query(&[(
1773                "name__iregex",
1774                &local_var_str
1775                    .into_iter()
1776                    .map(|p| p.to_string())
1777                    .collect::<Vec<String>>()
1778                    .join(",")
1779                    .to_string(),
1780            )]),
1781        };
1782    }
1783    if let Some(ref local_var_str) = name__isw {
1784        local_var_req_builder = match "multi" {
1785            "multi" => local_var_req_builder.query(
1786                &local_var_str
1787                    .into_iter()
1788                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1790            ),
1791            _ => local_var_req_builder.query(&[(
1792                "name__isw",
1793                &local_var_str
1794                    .into_iter()
1795                    .map(|p| p.to_string())
1796                    .collect::<Vec<String>>()
1797                    .join(",")
1798                    .to_string(),
1799            )]),
1800        };
1801    }
1802    if let Some(ref local_var_str) = name__n {
1803        local_var_req_builder = match "multi" {
1804            "multi" => local_var_req_builder.query(
1805                &local_var_str
1806                    .into_iter()
1807                    .map(|p| ("name__n".to_owned(), p.to_string()))
1808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1809            ),
1810            _ => local_var_req_builder.query(&[(
1811                "name__n",
1812                &local_var_str
1813                    .into_iter()
1814                    .map(|p| p.to_string())
1815                    .collect::<Vec<String>>()
1816                    .join(",")
1817                    .to_string(),
1818            )]),
1819        };
1820    }
1821    if let Some(ref local_var_str) = name__nic {
1822        local_var_req_builder = match "multi" {
1823            "multi" => local_var_req_builder.query(
1824                &local_var_str
1825                    .into_iter()
1826                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1828            ),
1829            _ => local_var_req_builder.query(&[(
1830                "name__nic",
1831                &local_var_str
1832                    .into_iter()
1833                    .map(|p| p.to_string())
1834                    .collect::<Vec<String>>()
1835                    .join(",")
1836                    .to_string(),
1837            )]),
1838        };
1839    }
1840    if let Some(ref local_var_str) = name__nie {
1841        local_var_req_builder = match "multi" {
1842            "multi" => local_var_req_builder.query(
1843                &local_var_str
1844                    .into_iter()
1845                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1847            ),
1848            _ => local_var_req_builder.query(&[(
1849                "name__nie",
1850                &local_var_str
1851                    .into_iter()
1852                    .map(|p| p.to_string())
1853                    .collect::<Vec<String>>()
1854                    .join(",")
1855                    .to_string(),
1856            )]),
1857        };
1858    }
1859    if let Some(ref local_var_str) = name__niew {
1860        local_var_req_builder = match "multi" {
1861            "multi" => local_var_req_builder.query(
1862                &local_var_str
1863                    .into_iter()
1864                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1866            ),
1867            _ => local_var_req_builder.query(&[(
1868                "name__niew",
1869                &local_var_str
1870                    .into_iter()
1871                    .map(|p| p.to_string())
1872                    .collect::<Vec<String>>()
1873                    .join(",")
1874                    .to_string(),
1875            )]),
1876        };
1877    }
1878    if let Some(ref local_var_str) = name__nisw {
1879        local_var_req_builder = match "multi" {
1880            "multi" => local_var_req_builder.query(
1881                &local_var_str
1882                    .into_iter()
1883                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1885            ),
1886            _ => local_var_req_builder.query(&[(
1887                "name__nisw",
1888                &local_var_str
1889                    .into_iter()
1890                    .map(|p| p.to_string())
1891                    .collect::<Vec<String>>()
1892                    .join(",")
1893                    .to_string(),
1894            )]),
1895        };
1896    }
1897    if let Some(ref local_var_str) = name__regex {
1898        local_var_req_builder = match "multi" {
1899            "multi" => local_var_req_builder.query(
1900                &local_var_str
1901                    .into_iter()
1902                    .map(|p| ("name__regex".to_owned(), p.to_string()))
1903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1904            ),
1905            _ => local_var_req_builder.query(&[(
1906                "name__regex",
1907                &local_var_str
1908                    .into_iter()
1909                    .map(|p| p.to_string())
1910                    .collect::<Vec<String>>()
1911                    .join(",")
1912                    .to_string(),
1913            )]),
1914        };
1915    }
1916    if let Some(ref local_var_str) = offset {
1917        local_var_req_builder =
1918            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1919    }
1920    if let Some(ref local_var_str) = ordering {
1921        local_var_req_builder =
1922            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1923    }
1924    if let Some(ref local_var_str) = q {
1925        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1926    }
1927    if let Some(ref local_var_str) = status {
1928        local_var_req_builder = match "multi" {
1929            "multi" => local_var_req_builder.query(
1930                &local_var_str
1931                    .into_iter()
1932                    .map(|p| ("status".to_owned(), p.to_string()))
1933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1934            ),
1935            _ => local_var_req_builder.query(&[(
1936                "status",
1937                &local_var_str
1938                    .into_iter()
1939                    .map(|p| p.to_string())
1940                    .collect::<Vec<String>>()
1941                    .join(",")
1942                    .to_string(),
1943            )]),
1944        };
1945    }
1946    if let Some(ref local_var_str) = status__empty {
1947        local_var_req_builder =
1948            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
1949    }
1950    if let Some(ref local_var_str) = status__ic {
1951        local_var_req_builder = match "multi" {
1952            "multi" => local_var_req_builder.query(
1953                &local_var_str
1954                    .into_iter()
1955                    .map(|p| ("status__ic".to_owned(), p.to_string()))
1956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1957            ),
1958            _ => local_var_req_builder.query(&[(
1959                "status__ic",
1960                &local_var_str
1961                    .into_iter()
1962                    .map(|p| p.to_string())
1963                    .collect::<Vec<String>>()
1964                    .join(",")
1965                    .to_string(),
1966            )]),
1967        };
1968    }
1969    if let Some(ref local_var_str) = status__ie {
1970        local_var_req_builder = match "multi" {
1971            "multi" => local_var_req_builder.query(
1972                &local_var_str
1973                    .into_iter()
1974                    .map(|p| ("status__ie".to_owned(), p.to_string()))
1975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1976            ),
1977            _ => local_var_req_builder.query(&[(
1978                "status__ie",
1979                &local_var_str
1980                    .into_iter()
1981                    .map(|p| p.to_string())
1982                    .collect::<Vec<String>>()
1983                    .join(",")
1984                    .to_string(),
1985            )]),
1986        };
1987    }
1988    if let Some(ref local_var_str) = status__iew {
1989        local_var_req_builder = match "multi" {
1990            "multi" => local_var_req_builder.query(
1991                &local_var_str
1992                    .into_iter()
1993                    .map(|p| ("status__iew".to_owned(), p.to_string()))
1994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1995            ),
1996            _ => local_var_req_builder.query(&[(
1997                "status__iew",
1998                &local_var_str
1999                    .into_iter()
2000                    .map(|p| p.to_string())
2001                    .collect::<Vec<String>>()
2002                    .join(",")
2003                    .to_string(),
2004            )]),
2005        };
2006    }
2007    if let Some(ref local_var_str) = status__iregex {
2008        local_var_req_builder = match "multi" {
2009            "multi" => local_var_req_builder.query(
2010                &local_var_str
2011                    .into_iter()
2012                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
2013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2014            ),
2015            _ => local_var_req_builder.query(&[(
2016                "status__iregex",
2017                &local_var_str
2018                    .into_iter()
2019                    .map(|p| p.to_string())
2020                    .collect::<Vec<String>>()
2021                    .join(",")
2022                    .to_string(),
2023            )]),
2024        };
2025    }
2026    if let Some(ref local_var_str) = status__isw {
2027        local_var_req_builder = match "multi" {
2028            "multi" => local_var_req_builder.query(
2029                &local_var_str
2030                    .into_iter()
2031                    .map(|p| ("status__isw".to_owned(), p.to_string()))
2032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2033            ),
2034            _ => local_var_req_builder.query(&[(
2035                "status__isw",
2036                &local_var_str
2037                    .into_iter()
2038                    .map(|p| p.to_string())
2039                    .collect::<Vec<String>>()
2040                    .join(",")
2041                    .to_string(),
2042            )]),
2043        };
2044    }
2045    if let Some(ref local_var_str) = status__n {
2046        local_var_req_builder = match "multi" {
2047            "multi" => local_var_req_builder.query(
2048                &local_var_str
2049                    .into_iter()
2050                    .map(|p| ("status__n".to_owned(), p.to_string()))
2051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2052            ),
2053            _ => local_var_req_builder.query(&[(
2054                "status__n",
2055                &local_var_str
2056                    .into_iter()
2057                    .map(|p| p.to_string())
2058                    .collect::<Vec<String>>()
2059                    .join(",")
2060                    .to_string(),
2061            )]),
2062        };
2063    }
2064    if let Some(ref local_var_str) = status__nic {
2065        local_var_req_builder = match "multi" {
2066            "multi" => local_var_req_builder.query(
2067                &local_var_str
2068                    .into_iter()
2069                    .map(|p| ("status__nic".to_owned(), p.to_string()))
2070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2071            ),
2072            _ => local_var_req_builder.query(&[(
2073                "status__nic",
2074                &local_var_str
2075                    .into_iter()
2076                    .map(|p| p.to_string())
2077                    .collect::<Vec<String>>()
2078                    .join(",")
2079                    .to_string(),
2080            )]),
2081        };
2082    }
2083    if let Some(ref local_var_str) = status__nie {
2084        local_var_req_builder = match "multi" {
2085            "multi" => local_var_req_builder.query(
2086                &local_var_str
2087                    .into_iter()
2088                    .map(|p| ("status__nie".to_owned(), p.to_string()))
2089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2090            ),
2091            _ => local_var_req_builder.query(&[(
2092                "status__nie",
2093                &local_var_str
2094                    .into_iter()
2095                    .map(|p| p.to_string())
2096                    .collect::<Vec<String>>()
2097                    .join(",")
2098                    .to_string(),
2099            )]),
2100        };
2101    }
2102    if let Some(ref local_var_str) = status__niew {
2103        local_var_req_builder = match "multi" {
2104            "multi" => local_var_req_builder.query(
2105                &local_var_str
2106                    .into_iter()
2107                    .map(|p| ("status__niew".to_owned(), p.to_string()))
2108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2109            ),
2110            _ => local_var_req_builder.query(&[(
2111                "status__niew",
2112                &local_var_str
2113                    .into_iter()
2114                    .map(|p| p.to_string())
2115                    .collect::<Vec<String>>()
2116                    .join(",")
2117                    .to_string(),
2118            )]),
2119        };
2120    }
2121    if let Some(ref local_var_str) = status__nisw {
2122        local_var_req_builder = match "multi" {
2123            "multi" => local_var_req_builder.query(
2124                &local_var_str
2125                    .into_iter()
2126                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
2127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2128            ),
2129            _ => local_var_req_builder.query(&[(
2130                "status__nisw",
2131                &local_var_str
2132                    .into_iter()
2133                    .map(|p| p.to_string())
2134                    .collect::<Vec<String>>()
2135                    .join(",")
2136                    .to_string(),
2137            )]),
2138        };
2139    }
2140    if let Some(ref local_var_str) = status__regex {
2141        local_var_req_builder = match "multi" {
2142            "multi" => local_var_req_builder.query(
2143                &local_var_str
2144                    .into_iter()
2145                    .map(|p| ("status__regex".to_owned(), p.to_string()))
2146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2147            ),
2148            _ => local_var_req_builder.query(&[(
2149                "status__regex",
2150                &local_var_str
2151                    .into_iter()
2152                    .map(|p| p.to_string())
2153                    .collect::<Vec<String>>()
2154                    .join(",")
2155                    .to_string(),
2156            )]),
2157        };
2158    }
2159    if let Some(ref local_var_str) = tag {
2160        local_var_req_builder = match "multi" {
2161            "multi" => local_var_req_builder.query(
2162                &local_var_str
2163                    .into_iter()
2164                    .map(|p| ("tag".to_owned(), p.to_string()))
2165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2166            ),
2167            _ => local_var_req_builder.query(&[(
2168                "tag",
2169                &local_var_str
2170                    .into_iter()
2171                    .map(|p| p.to_string())
2172                    .collect::<Vec<String>>()
2173                    .join(",")
2174                    .to_string(),
2175            )]),
2176        };
2177    }
2178    if let Some(ref local_var_str) = tag__n {
2179        local_var_req_builder = match "multi" {
2180            "multi" => local_var_req_builder.query(
2181                &local_var_str
2182                    .into_iter()
2183                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2185            ),
2186            _ => local_var_req_builder.query(&[(
2187                "tag__n",
2188                &local_var_str
2189                    .into_iter()
2190                    .map(|p| p.to_string())
2191                    .collect::<Vec<String>>()
2192                    .join(",")
2193                    .to_string(),
2194            )]),
2195        };
2196    }
2197    if let Some(ref local_var_str) = tag_id {
2198        local_var_req_builder = match "multi" {
2199            "multi" => local_var_req_builder.query(
2200                &local_var_str
2201                    .into_iter()
2202                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2204            ),
2205            _ => local_var_req_builder.query(&[(
2206                "tag_id",
2207                &local_var_str
2208                    .into_iter()
2209                    .map(|p| p.to_string())
2210                    .collect::<Vec<String>>()
2211                    .join(",")
2212                    .to_string(),
2213            )]),
2214        };
2215    }
2216    if let Some(ref local_var_str) = tag_id__n {
2217        local_var_req_builder = match "multi" {
2218            "multi" => local_var_req_builder.query(
2219                &local_var_str
2220                    .into_iter()
2221                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2223            ),
2224            _ => local_var_req_builder.query(&[(
2225                "tag_id__n",
2226                &local_var_str
2227                    .into_iter()
2228                    .map(|p| p.to_string())
2229                    .collect::<Vec<String>>()
2230                    .join(",")
2231                    .to_string(),
2232            )]),
2233        };
2234    }
2235    if let Some(ref local_var_str) = updated_by_request {
2236        local_var_req_builder =
2237            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2238    }
2239    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2240        local_var_req_builder =
2241            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2242    }
2243    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2244        let local_var_key = local_var_apikey.key.clone();
2245        let local_var_value = match local_var_apikey.prefix {
2246            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2247            None => local_var_key,
2248        };
2249        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2250    };
2251
2252    let local_var_req = local_var_req_builder.build()?;
2253    let local_var_resp = local_var_client.execute(local_var_req).await?;
2254
2255    let local_var_status = local_var_resp.status();
2256    let local_var_content = local_var_resp.text().await?;
2257
2258    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2259        serde_json::from_str(&local_var_content).map_err(Error::from)
2260    } else {
2261        let local_var_entity: Option<PluginsBranchingBranchesListError> =
2262            serde_json::from_str(&local_var_content).ok();
2263        let local_var_error = ResponseContent {
2264            status: local_var_status,
2265            content: local_var_content,
2266            entity: local_var_entity,
2267        };
2268        Err(Error::ResponseError(local_var_error))
2269    }
2270}
2271
2272/// Enqueue a background job to merge a branch.
2273pub async fn plugins_branching_branches_merge_create(
2274    configuration: &configuration::Configuration,
2275    id: i32,
2276    commit_request: Option<crate::models::CommitRequest>,
2277) -> Result<crate::models::Job, Error<PluginsBranchingBranchesMergeCreateError>> {
2278    let local_var_configuration = configuration;
2279
2280    let local_var_client = &local_var_configuration.client;
2281
2282    let local_var_uri_str = format!(
2283        "{}/api/plugins/branching/branches/{id}/merge/",
2284        local_var_configuration.base_path,
2285        id = id
2286    );
2287    let mut local_var_req_builder =
2288        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2289
2290    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2291        local_var_req_builder =
2292            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2293    }
2294    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2295        let local_var_key = local_var_apikey.key.clone();
2296        let local_var_value = match local_var_apikey.prefix {
2297            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2298            None => local_var_key,
2299        };
2300        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2301    };
2302    local_var_req_builder = local_var_req_builder.json(&commit_request);
2303
2304    let local_var_req = local_var_req_builder.build()?;
2305    let local_var_resp = local_var_client.execute(local_var_req).await?;
2306
2307    let local_var_status = local_var_resp.status();
2308    let local_var_content = local_var_resp.text().await?;
2309
2310    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2311        serde_json::from_str(&local_var_content).map_err(Error::from)
2312    } else {
2313        let local_var_entity: Option<PluginsBranchingBranchesMergeCreateError> =
2314            serde_json::from_str(&local_var_content).ok();
2315        let local_var_error = ResponseContent {
2316            status: local_var_status,
2317            content: local_var_content,
2318            entity: local_var_entity,
2319        };
2320        Err(Error::ResponseError(local_var_error))
2321    }
2322}
2323
2324/// Patch a branch object.
2325pub async fn plugins_branching_branches_partial_update(
2326    configuration: &configuration::Configuration,
2327    id: i32,
2328    patched_writable_branch_request: Option<crate::models::PatchedWritableBranchRequest>,
2329) -> Result<crate::models::Branch, Error<PluginsBranchingBranchesPartialUpdateError>> {
2330    let local_var_configuration = configuration;
2331
2332    let local_var_client = &local_var_configuration.client;
2333
2334    let local_var_uri_str = format!(
2335        "{}/api/plugins/branching/branches/{id}/",
2336        local_var_configuration.base_path,
2337        id = id
2338    );
2339    let mut local_var_req_builder =
2340        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2341
2342    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2343        local_var_req_builder =
2344            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2345    }
2346    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2347        let local_var_key = local_var_apikey.key.clone();
2348        let local_var_value = match local_var_apikey.prefix {
2349            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2350            None => local_var_key,
2351        };
2352        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2353    };
2354    local_var_req_builder = local_var_req_builder.json(&patched_writable_branch_request);
2355
2356    let local_var_req = local_var_req_builder.build()?;
2357    let local_var_resp = local_var_client.execute(local_var_req).await?;
2358
2359    let local_var_status = local_var_resp.status();
2360    let local_var_content = local_var_resp.text().await?;
2361
2362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2363        serde_json::from_str(&local_var_content).map_err(Error::from)
2364    } else {
2365        let local_var_entity: Option<PluginsBranchingBranchesPartialUpdateError> =
2366            serde_json::from_str(&local_var_content).ok();
2367        let local_var_error = ResponseContent {
2368            status: local_var_status,
2369            content: local_var_content,
2370            entity: local_var_entity,
2371        };
2372        Err(Error::ResponseError(local_var_error))
2373    }
2374}
2375
2376/// Get a branch object.
2377pub async fn plugins_branching_branches_retrieve(
2378    configuration: &configuration::Configuration,
2379    id: i32,
2380) -> Result<crate::models::Branch, Error<PluginsBranchingBranchesRetrieveError>> {
2381    let local_var_configuration = configuration;
2382
2383    let local_var_client = &local_var_configuration.client;
2384
2385    let local_var_uri_str = format!(
2386        "{}/api/plugins/branching/branches/{id}/",
2387        local_var_configuration.base_path,
2388        id = id
2389    );
2390    let mut local_var_req_builder =
2391        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2392
2393    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2394        local_var_req_builder =
2395            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2396    }
2397    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2398        let local_var_key = local_var_apikey.key.clone();
2399        let local_var_value = match local_var_apikey.prefix {
2400            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2401            None => local_var_key,
2402        };
2403        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2404    };
2405
2406    let local_var_req = local_var_req_builder.build()?;
2407    let local_var_resp = local_var_client.execute(local_var_req).await?;
2408
2409    let local_var_status = local_var_resp.status();
2410    let local_var_content = local_var_resp.text().await?;
2411
2412    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2413        serde_json::from_str(&local_var_content).map_err(Error::from)
2414    } else {
2415        let local_var_entity: Option<PluginsBranchingBranchesRetrieveError> =
2416            serde_json::from_str(&local_var_content).ok();
2417        let local_var_error = ResponseContent {
2418            status: local_var_status,
2419            content: local_var_content,
2420            entity: local_var_entity,
2421        };
2422        Err(Error::ResponseError(local_var_error))
2423    }
2424}
2425
2426/// Enqueue a background job to revert a merged branch.
2427pub async fn plugins_branching_branches_revert_create(
2428    configuration: &configuration::Configuration,
2429    id: i32,
2430    commit_request: Option<crate::models::CommitRequest>,
2431) -> Result<crate::models::Job, Error<PluginsBranchingBranchesRevertCreateError>> {
2432    let local_var_configuration = configuration;
2433
2434    let local_var_client = &local_var_configuration.client;
2435
2436    let local_var_uri_str = format!(
2437        "{}/api/plugins/branching/branches/{id}/revert/",
2438        local_var_configuration.base_path,
2439        id = id
2440    );
2441    let mut local_var_req_builder =
2442        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2443
2444    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2445        local_var_req_builder =
2446            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2447    }
2448    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2449        let local_var_key = local_var_apikey.key.clone();
2450        let local_var_value = match local_var_apikey.prefix {
2451            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2452            None => local_var_key,
2453        };
2454        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2455    };
2456    local_var_req_builder = local_var_req_builder.json(&commit_request);
2457
2458    let local_var_req = local_var_req_builder.build()?;
2459    let local_var_resp = local_var_client.execute(local_var_req).await?;
2460
2461    let local_var_status = local_var_resp.status();
2462    let local_var_content = local_var_resp.text().await?;
2463
2464    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2465        serde_json::from_str(&local_var_content).map_err(Error::from)
2466    } else {
2467        let local_var_entity: Option<PluginsBranchingBranchesRevertCreateError> =
2468            serde_json::from_str(&local_var_content).ok();
2469        let local_var_error = ResponseContent {
2470            status: local_var_status,
2471            content: local_var_content,
2472            entity: local_var_entity,
2473        };
2474        Err(Error::ResponseError(local_var_error))
2475    }
2476}
2477
2478/// Enqueue a background job to synchronize a branch from main.
2479pub async fn plugins_branching_branches_sync_create(
2480    configuration: &configuration::Configuration,
2481    id: i32,
2482    commit_request: Option<crate::models::CommitRequest>,
2483) -> Result<crate::models::Job, Error<PluginsBranchingBranchesSyncCreateError>> {
2484    let local_var_configuration = configuration;
2485
2486    let local_var_client = &local_var_configuration.client;
2487
2488    let local_var_uri_str = format!(
2489        "{}/api/plugins/branching/branches/{id}/sync/",
2490        local_var_configuration.base_path,
2491        id = id
2492    );
2493    let mut local_var_req_builder =
2494        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2495
2496    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2497        local_var_req_builder =
2498            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2499    }
2500    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2501        let local_var_key = local_var_apikey.key.clone();
2502        let local_var_value = match local_var_apikey.prefix {
2503            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2504            None => local_var_key,
2505        };
2506        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2507    };
2508    local_var_req_builder = local_var_req_builder.json(&commit_request);
2509
2510    let local_var_req = local_var_req_builder.build()?;
2511    let local_var_resp = local_var_client.execute(local_var_req).await?;
2512
2513    let local_var_status = local_var_resp.status();
2514    let local_var_content = local_var_resp.text().await?;
2515
2516    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2517        serde_json::from_str(&local_var_content).map_err(Error::from)
2518    } else {
2519        let local_var_entity: Option<PluginsBranchingBranchesSyncCreateError> =
2520            serde_json::from_str(&local_var_content).ok();
2521        let local_var_error = ResponseContent {
2522            status: local_var_status,
2523            content: local_var_content,
2524            entity: local_var_entity,
2525        };
2526        Err(Error::ResponseError(local_var_error))
2527    }
2528}
2529
2530/// Put a branch object.
2531pub async fn plugins_branching_branches_update(
2532    configuration: &configuration::Configuration,
2533    id: i32,
2534    writable_branch_request: crate::models::WritableBranchRequest,
2535) -> Result<crate::models::Branch, Error<PluginsBranchingBranchesUpdateError>> {
2536    let local_var_configuration = configuration;
2537
2538    let local_var_client = &local_var_configuration.client;
2539
2540    let local_var_uri_str = format!(
2541        "{}/api/plugins/branching/branches/{id}/",
2542        local_var_configuration.base_path,
2543        id = id
2544    );
2545    let mut local_var_req_builder =
2546        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2547
2548    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2549        local_var_req_builder =
2550            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2551    }
2552    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2553        let local_var_key = local_var_apikey.key.clone();
2554        let local_var_value = match local_var_apikey.prefix {
2555            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2556            None => local_var_key,
2557        };
2558        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2559    };
2560    local_var_req_builder = local_var_req_builder.json(&writable_branch_request);
2561
2562    let local_var_req = local_var_req_builder.build()?;
2563    let local_var_resp = local_var_client.execute(local_var_req).await?;
2564
2565    let local_var_status = local_var_resp.status();
2566    let local_var_content = local_var_resp.text().await?;
2567
2568    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2569        serde_json::from_str(&local_var_content).map_err(Error::from)
2570    } else {
2571        let local_var_entity: Option<PluginsBranchingBranchesUpdateError> =
2572            serde_json::from_str(&local_var_content).ok();
2573        let local_var_error = ResponseContent {
2574            status: local_var_status,
2575            content: local_var_content,
2576            entity: local_var_entity,
2577        };
2578        Err(Error::ResponseError(local_var_error))
2579    }
2580}
2581
2582/// Get a list of change diff objects.
2583pub async fn plugins_branching_changes_list(
2584    configuration: &configuration::Configuration,
2585    action: Option<Vec<String>>,
2586    action__empty: Option<bool>,
2587    action__ic: Option<Vec<String>>,
2588    action__ie: Option<Vec<String>>,
2589    action__iew: Option<Vec<String>>,
2590    action__iregex: Option<Vec<String>>,
2591    action__isw: Option<Vec<String>>,
2592    action__n: Option<Vec<String>>,
2593    action__nic: Option<Vec<String>>,
2594    action__nie: Option<Vec<String>>,
2595    action__niew: Option<Vec<String>>,
2596    action__nisw: Option<Vec<String>>,
2597    action__regex: Option<Vec<String>>,
2598    branch: Option<Vec<String>>,
2599    branch__n: Option<Vec<String>>,
2600    branch_id: Option<Vec<i32>>,
2601    branch_id__n: Option<Vec<i32>>,
2602    has_conflicts: Option<bool>,
2603    id: Option<Vec<i32>>,
2604    id__empty: Option<bool>,
2605    id__gt: Option<Vec<i32>>,
2606    id__gte: Option<Vec<i32>>,
2607    id__lt: Option<Vec<i32>>,
2608    id__lte: Option<Vec<i32>>,
2609    id__n: Option<Vec<i32>>,
2610    last_updated: Option<Vec<String>>,
2611    last_updated__empty: Option<Vec<String>>,
2612    last_updated__gt: Option<Vec<String>>,
2613    last_updated__gte: Option<Vec<String>>,
2614    last_updated__lt: Option<Vec<String>>,
2615    last_updated__lte: Option<Vec<String>>,
2616    last_updated__n: Option<Vec<String>>,
2617    limit: Option<i32>,
2618    object_id: Option<Vec<i32>>,
2619    object_id__empty: Option<bool>,
2620    object_id__gt: Option<Vec<i32>>,
2621    object_id__gte: Option<Vec<i32>>,
2622    object_id__lt: Option<Vec<i32>>,
2623    object_id__lte: Option<Vec<i32>>,
2624    object_id__n: Option<Vec<i32>>,
2625    object_type: Option<&str>,
2626    object_type__n: Option<&str>,
2627    object_type_id: Option<Vec<i32>>,
2628    object_type_id__n: Option<Vec<i32>>,
2629    offset: Option<i32>,
2630    ordering: Option<&str>,
2631    q: Option<&str>,
2632) -> Result<crate::models::PaginatedChangeDiffList, Error<PluginsBranchingChangesListError>> {
2633    let local_var_configuration = configuration;
2634
2635    let local_var_client = &local_var_configuration.client;
2636
2637    let local_var_uri_str = format!(
2638        "{}/api/plugins/branching/changes/",
2639        local_var_configuration.base_path
2640    );
2641    let mut local_var_req_builder =
2642        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2643
2644    if let Some(ref local_var_str) = action {
2645        local_var_req_builder = match "multi" {
2646            "multi" => local_var_req_builder.query(
2647                &local_var_str
2648                    .into_iter()
2649                    .map(|p| ("action".to_owned(), p.to_string()))
2650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2651            ),
2652            _ => local_var_req_builder.query(&[(
2653                "action",
2654                &local_var_str
2655                    .into_iter()
2656                    .map(|p| p.to_string())
2657                    .collect::<Vec<String>>()
2658                    .join(",")
2659                    .to_string(),
2660            )]),
2661        };
2662    }
2663    if let Some(ref local_var_str) = action__empty {
2664        local_var_req_builder =
2665            local_var_req_builder.query(&[("action__empty", &local_var_str.to_string())]);
2666    }
2667    if let Some(ref local_var_str) = action__ic {
2668        local_var_req_builder = match "multi" {
2669            "multi" => local_var_req_builder.query(
2670                &local_var_str
2671                    .into_iter()
2672                    .map(|p| ("action__ic".to_owned(), p.to_string()))
2673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2674            ),
2675            _ => local_var_req_builder.query(&[(
2676                "action__ic",
2677                &local_var_str
2678                    .into_iter()
2679                    .map(|p| p.to_string())
2680                    .collect::<Vec<String>>()
2681                    .join(",")
2682                    .to_string(),
2683            )]),
2684        };
2685    }
2686    if let Some(ref local_var_str) = action__ie {
2687        local_var_req_builder = match "multi" {
2688            "multi" => local_var_req_builder.query(
2689                &local_var_str
2690                    .into_iter()
2691                    .map(|p| ("action__ie".to_owned(), p.to_string()))
2692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2693            ),
2694            _ => local_var_req_builder.query(&[(
2695                "action__ie",
2696                &local_var_str
2697                    .into_iter()
2698                    .map(|p| p.to_string())
2699                    .collect::<Vec<String>>()
2700                    .join(",")
2701                    .to_string(),
2702            )]),
2703        };
2704    }
2705    if let Some(ref local_var_str) = action__iew {
2706        local_var_req_builder = match "multi" {
2707            "multi" => local_var_req_builder.query(
2708                &local_var_str
2709                    .into_iter()
2710                    .map(|p| ("action__iew".to_owned(), p.to_string()))
2711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2712            ),
2713            _ => local_var_req_builder.query(&[(
2714                "action__iew",
2715                &local_var_str
2716                    .into_iter()
2717                    .map(|p| p.to_string())
2718                    .collect::<Vec<String>>()
2719                    .join(",")
2720                    .to_string(),
2721            )]),
2722        };
2723    }
2724    if let Some(ref local_var_str) = action__iregex {
2725        local_var_req_builder = match "multi" {
2726            "multi" => local_var_req_builder.query(
2727                &local_var_str
2728                    .into_iter()
2729                    .map(|p| ("action__iregex".to_owned(), p.to_string()))
2730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2731            ),
2732            _ => local_var_req_builder.query(&[(
2733                "action__iregex",
2734                &local_var_str
2735                    .into_iter()
2736                    .map(|p| p.to_string())
2737                    .collect::<Vec<String>>()
2738                    .join(",")
2739                    .to_string(),
2740            )]),
2741        };
2742    }
2743    if let Some(ref local_var_str) = action__isw {
2744        local_var_req_builder = match "multi" {
2745            "multi" => local_var_req_builder.query(
2746                &local_var_str
2747                    .into_iter()
2748                    .map(|p| ("action__isw".to_owned(), p.to_string()))
2749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2750            ),
2751            _ => local_var_req_builder.query(&[(
2752                "action__isw",
2753                &local_var_str
2754                    .into_iter()
2755                    .map(|p| p.to_string())
2756                    .collect::<Vec<String>>()
2757                    .join(",")
2758                    .to_string(),
2759            )]),
2760        };
2761    }
2762    if let Some(ref local_var_str) = action__n {
2763        local_var_req_builder = match "multi" {
2764            "multi" => local_var_req_builder.query(
2765                &local_var_str
2766                    .into_iter()
2767                    .map(|p| ("action__n".to_owned(), p.to_string()))
2768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2769            ),
2770            _ => local_var_req_builder.query(&[(
2771                "action__n",
2772                &local_var_str
2773                    .into_iter()
2774                    .map(|p| p.to_string())
2775                    .collect::<Vec<String>>()
2776                    .join(",")
2777                    .to_string(),
2778            )]),
2779        };
2780    }
2781    if let Some(ref local_var_str) = action__nic {
2782        local_var_req_builder = match "multi" {
2783            "multi" => local_var_req_builder.query(
2784                &local_var_str
2785                    .into_iter()
2786                    .map(|p| ("action__nic".to_owned(), p.to_string()))
2787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2788            ),
2789            _ => local_var_req_builder.query(&[(
2790                "action__nic",
2791                &local_var_str
2792                    .into_iter()
2793                    .map(|p| p.to_string())
2794                    .collect::<Vec<String>>()
2795                    .join(",")
2796                    .to_string(),
2797            )]),
2798        };
2799    }
2800    if let Some(ref local_var_str) = action__nie {
2801        local_var_req_builder = match "multi" {
2802            "multi" => local_var_req_builder.query(
2803                &local_var_str
2804                    .into_iter()
2805                    .map(|p| ("action__nie".to_owned(), p.to_string()))
2806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2807            ),
2808            _ => local_var_req_builder.query(&[(
2809                "action__nie",
2810                &local_var_str
2811                    .into_iter()
2812                    .map(|p| p.to_string())
2813                    .collect::<Vec<String>>()
2814                    .join(",")
2815                    .to_string(),
2816            )]),
2817        };
2818    }
2819    if let Some(ref local_var_str) = action__niew {
2820        local_var_req_builder = match "multi" {
2821            "multi" => local_var_req_builder.query(
2822                &local_var_str
2823                    .into_iter()
2824                    .map(|p| ("action__niew".to_owned(), p.to_string()))
2825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2826            ),
2827            _ => local_var_req_builder.query(&[(
2828                "action__niew",
2829                &local_var_str
2830                    .into_iter()
2831                    .map(|p| p.to_string())
2832                    .collect::<Vec<String>>()
2833                    .join(",")
2834                    .to_string(),
2835            )]),
2836        };
2837    }
2838    if let Some(ref local_var_str) = action__nisw {
2839        local_var_req_builder = match "multi" {
2840            "multi" => local_var_req_builder.query(
2841                &local_var_str
2842                    .into_iter()
2843                    .map(|p| ("action__nisw".to_owned(), p.to_string()))
2844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2845            ),
2846            _ => local_var_req_builder.query(&[(
2847                "action__nisw",
2848                &local_var_str
2849                    .into_iter()
2850                    .map(|p| p.to_string())
2851                    .collect::<Vec<String>>()
2852                    .join(",")
2853                    .to_string(),
2854            )]),
2855        };
2856    }
2857    if let Some(ref local_var_str) = action__regex {
2858        local_var_req_builder = match "multi" {
2859            "multi" => local_var_req_builder.query(
2860                &local_var_str
2861                    .into_iter()
2862                    .map(|p| ("action__regex".to_owned(), p.to_string()))
2863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2864            ),
2865            _ => local_var_req_builder.query(&[(
2866                "action__regex",
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) = branch {
2877        local_var_req_builder = match "multi" {
2878            "multi" => local_var_req_builder.query(
2879                &local_var_str
2880                    .into_iter()
2881                    .map(|p| ("branch".to_owned(), p.to_string()))
2882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2883            ),
2884            _ => local_var_req_builder.query(&[(
2885                "branch",
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) = branch__n {
2896        local_var_req_builder = match "multi" {
2897            "multi" => local_var_req_builder.query(
2898                &local_var_str
2899                    .into_iter()
2900                    .map(|p| ("branch__n".to_owned(), p.to_string()))
2901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2902            ),
2903            _ => local_var_req_builder.query(&[(
2904                "branch__n",
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) = branch_id {
2915        local_var_req_builder = match "multi" {
2916            "multi" => local_var_req_builder.query(
2917                &local_var_str
2918                    .into_iter()
2919                    .map(|p| ("branch_id".to_owned(), p.to_string()))
2920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2921            ),
2922            _ => local_var_req_builder.query(&[(
2923                "branch_id",
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) = branch_id__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| ("branch_id__n".to_owned(), p.to_string()))
2939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2940            ),
2941            _ => local_var_req_builder.query(&[(
2942                "branch_id__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) = has_conflicts {
2953        local_var_req_builder =
2954            local_var_req_builder.query(&[("has_conflicts", &local_var_str.to_string())]);
2955    }
2956    if let Some(ref local_var_str) = id {
2957        local_var_req_builder = match "multi" {
2958            "multi" => local_var_req_builder.query(
2959                &local_var_str
2960                    .into_iter()
2961                    .map(|p| ("id".to_owned(), p.to_string()))
2962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2963            ),
2964            _ => local_var_req_builder.query(&[(
2965                "id",
2966                &local_var_str
2967                    .into_iter()
2968                    .map(|p| p.to_string())
2969                    .collect::<Vec<String>>()
2970                    .join(",")
2971                    .to_string(),
2972            )]),
2973        };
2974    }
2975    if let Some(ref local_var_str) = id__empty {
2976        local_var_req_builder =
2977            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2978    }
2979    if let Some(ref local_var_str) = id__gt {
2980        local_var_req_builder = match "multi" {
2981            "multi" => local_var_req_builder.query(
2982                &local_var_str
2983                    .into_iter()
2984                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2986            ),
2987            _ => local_var_req_builder.query(&[(
2988                "id__gt",
2989                &local_var_str
2990                    .into_iter()
2991                    .map(|p| p.to_string())
2992                    .collect::<Vec<String>>()
2993                    .join(",")
2994                    .to_string(),
2995            )]),
2996        };
2997    }
2998    if let Some(ref local_var_str) = id__gte {
2999        local_var_req_builder = match "multi" {
3000            "multi" => local_var_req_builder.query(
3001                &local_var_str
3002                    .into_iter()
3003                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3005            ),
3006            _ => local_var_req_builder.query(&[(
3007                "id__gte",
3008                &local_var_str
3009                    .into_iter()
3010                    .map(|p| p.to_string())
3011                    .collect::<Vec<String>>()
3012                    .join(",")
3013                    .to_string(),
3014            )]),
3015        };
3016    }
3017    if let Some(ref local_var_str) = id__lt {
3018        local_var_req_builder = match "multi" {
3019            "multi" => local_var_req_builder.query(
3020                &local_var_str
3021                    .into_iter()
3022                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3024            ),
3025            _ => local_var_req_builder.query(&[(
3026                "id__lt",
3027                &local_var_str
3028                    .into_iter()
3029                    .map(|p| p.to_string())
3030                    .collect::<Vec<String>>()
3031                    .join(",")
3032                    .to_string(),
3033            )]),
3034        };
3035    }
3036    if let Some(ref local_var_str) = id__lte {
3037        local_var_req_builder = match "multi" {
3038            "multi" => local_var_req_builder.query(
3039                &local_var_str
3040                    .into_iter()
3041                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3043            ),
3044            _ => local_var_req_builder.query(&[(
3045                "id__lte",
3046                &local_var_str
3047                    .into_iter()
3048                    .map(|p| p.to_string())
3049                    .collect::<Vec<String>>()
3050                    .join(",")
3051                    .to_string(),
3052            )]),
3053        };
3054    }
3055    if let Some(ref local_var_str) = id__n {
3056        local_var_req_builder = match "multi" {
3057            "multi" => local_var_req_builder.query(
3058                &local_var_str
3059                    .into_iter()
3060                    .map(|p| ("id__n".to_owned(), p.to_string()))
3061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3062            ),
3063            _ => local_var_req_builder.query(&[(
3064                "id__n",
3065                &local_var_str
3066                    .into_iter()
3067                    .map(|p| p.to_string())
3068                    .collect::<Vec<String>>()
3069                    .join(",")
3070                    .to_string(),
3071            )]),
3072        };
3073    }
3074    if let Some(ref local_var_str) = last_updated {
3075        local_var_req_builder = match "multi" {
3076            "multi" => local_var_req_builder.query(
3077                &local_var_str
3078                    .into_iter()
3079                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3081            ),
3082            _ => local_var_req_builder.query(&[(
3083                "last_updated",
3084                &local_var_str
3085                    .into_iter()
3086                    .map(|p| p.to_string())
3087                    .collect::<Vec<String>>()
3088                    .join(",")
3089                    .to_string(),
3090            )]),
3091        };
3092    }
3093    if let Some(ref local_var_str) = last_updated__empty {
3094        local_var_req_builder = match "multi" {
3095            "multi" => local_var_req_builder.query(
3096                &local_var_str
3097                    .into_iter()
3098                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3100            ),
3101            _ => local_var_req_builder.query(&[(
3102                "last_updated__empty",
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) = last_updated__gt {
3113        local_var_req_builder = match "multi" {
3114            "multi" => local_var_req_builder.query(
3115                &local_var_str
3116                    .into_iter()
3117                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3119            ),
3120            _ => local_var_req_builder.query(&[(
3121                "last_updated__gt",
3122                &local_var_str
3123                    .into_iter()
3124                    .map(|p| p.to_string())
3125                    .collect::<Vec<String>>()
3126                    .join(",")
3127                    .to_string(),
3128            )]),
3129        };
3130    }
3131    if let Some(ref local_var_str) = last_updated__gte {
3132        local_var_req_builder = match "multi" {
3133            "multi" => local_var_req_builder.query(
3134                &local_var_str
3135                    .into_iter()
3136                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3138            ),
3139            _ => local_var_req_builder.query(&[(
3140                "last_updated__gte",
3141                &local_var_str
3142                    .into_iter()
3143                    .map(|p| p.to_string())
3144                    .collect::<Vec<String>>()
3145                    .join(",")
3146                    .to_string(),
3147            )]),
3148        };
3149    }
3150    if let Some(ref local_var_str) = last_updated__lt {
3151        local_var_req_builder = match "multi" {
3152            "multi" => local_var_req_builder.query(
3153                &local_var_str
3154                    .into_iter()
3155                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3157            ),
3158            _ => local_var_req_builder.query(&[(
3159                "last_updated__lt",
3160                &local_var_str
3161                    .into_iter()
3162                    .map(|p| p.to_string())
3163                    .collect::<Vec<String>>()
3164                    .join(",")
3165                    .to_string(),
3166            )]),
3167        };
3168    }
3169    if let Some(ref local_var_str) = last_updated__lte {
3170        local_var_req_builder = match "multi" {
3171            "multi" => local_var_req_builder.query(
3172                &local_var_str
3173                    .into_iter()
3174                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3176            ),
3177            _ => local_var_req_builder.query(&[(
3178                "last_updated__lte",
3179                &local_var_str
3180                    .into_iter()
3181                    .map(|p| p.to_string())
3182                    .collect::<Vec<String>>()
3183                    .join(",")
3184                    .to_string(),
3185            )]),
3186        };
3187    }
3188    if let Some(ref local_var_str) = last_updated__n {
3189        local_var_req_builder = match "multi" {
3190            "multi" => local_var_req_builder.query(
3191                &local_var_str
3192                    .into_iter()
3193                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3195            ),
3196            _ => local_var_req_builder.query(&[(
3197                "last_updated__n",
3198                &local_var_str
3199                    .into_iter()
3200                    .map(|p| p.to_string())
3201                    .collect::<Vec<String>>()
3202                    .join(",")
3203                    .to_string(),
3204            )]),
3205        };
3206    }
3207    if let Some(ref local_var_str) = limit {
3208        local_var_req_builder =
3209            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3210    }
3211    if let Some(ref local_var_str) = object_id {
3212        local_var_req_builder = match "multi" {
3213            "multi" => local_var_req_builder.query(
3214                &local_var_str
3215                    .into_iter()
3216                    .map(|p| ("object_id".to_owned(), p.to_string()))
3217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3218            ),
3219            _ => local_var_req_builder.query(&[(
3220                "object_id",
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) = object_id__empty {
3231        local_var_req_builder =
3232            local_var_req_builder.query(&[("object_id__empty", &local_var_str.to_string())]);
3233    }
3234    if let Some(ref local_var_str) = object_id__gt {
3235        local_var_req_builder = match "multi" {
3236            "multi" => local_var_req_builder.query(
3237                &local_var_str
3238                    .into_iter()
3239                    .map(|p| ("object_id__gt".to_owned(), p.to_string()))
3240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3241            ),
3242            _ => local_var_req_builder.query(&[(
3243                "object_id__gt",
3244                &local_var_str
3245                    .into_iter()
3246                    .map(|p| p.to_string())
3247                    .collect::<Vec<String>>()
3248                    .join(",")
3249                    .to_string(),
3250            )]),
3251        };
3252    }
3253    if let Some(ref local_var_str) = object_id__gte {
3254        local_var_req_builder = match "multi" {
3255            "multi" => local_var_req_builder.query(
3256                &local_var_str
3257                    .into_iter()
3258                    .map(|p| ("object_id__gte".to_owned(), p.to_string()))
3259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3260            ),
3261            _ => local_var_req_builder.query(&[(
3262                "object_id__gte",
3263                &local_var_str
3264                    .into_iter()
3265                    .map(|p| p.to_string())
3266                    .collect::<Vec<String>>()
3267                    .join(",")
3268                    .to_string(),
3269            )]),
3270        };
3271    }
3272    if let Some(ref local_var_str) = object_id__lt {
3273        local_var_req_builder = match "multi" {
3274            "multi" => local_var_req_builder.query(
3275                &local_var_str
3276                    .into_iter()
3277                    .map(|p| ("object_id__lt".to_owned(), p.to_string()))
3278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3279            ),
3280            _ => local_var_req_builder.query(&[(
3281                "object_id__lt",
3282                &local_var_str
3283                    .into_iter()
3284                    .map(|p| p.to_string())
3285                    .collect::<Vec<String>>()
3286                    .join(",")
3287                    .to_string(),
3288            )]),
3289        };
3290    }
3291    if let Some(ref local_var_str) = object_id__lte {
3292        local_var_req_builder = match "multi" {
3293            "multi" => local_var_req_builder.query(
3294                &local_var_str
3295                    .into_iter()
3296                    .map(|p| ("object_id__lte".to_owned(), p.to_string()))
3297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3298            ),
3299            _ => local_var_req_builder.query(&[(
3300                "object_id__lte",
3301                &local_var_str
3302                    .into_iter()
3303                    .map(|p| p.to_string())
3304                    .collect::<Vec<String>>()
3305                    .join(",")
3306                    .to_string(),
3307            )]),
3308        };
3309    }
3310    if let Some(ref local_var_str) = object_id__n {
3311        local_var_req_builder = match "multi" {
3312            "multi" => local_var_req_builder.query(
3313                &local_var_str
3314                    .into_iter()
3315                    .map(|p| ("object_id__n".to_owned(), p.to_string()))
3316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3317            ),
3318            _ => local_var_req_builder.query(&[(
3319                "object_id__n",
3320                &local_var_str
3321                    .into_iter()
3322                    .map(|p| p.to_string())
3323                    .collect::<Vec<String>>()
3324                    .join(",")
3325                    .to_string(),
3326            )]),
3327        };
3328    }
3329    if let Some(ref local_var_str) = object_type {
3330        local_var_req_builder =
3331            local_var_req_builder.query(&[("object_type", &local_var_str.to_string())]);
3332    }
3333    if let Some(ref local_var_str) = object_type__n {
3334        local_var_req_builder =
3335            local_var_req_builder.query(&[("object_type__n", &local_var_str.to_string())]);
3336    }
3337    if let Some(ref local_var_str) = object_type_id {
3338        local_var_req_builder = match "multi" {
3339            "multi" => local_var_req_builder.query(
3340                &local_var_str
3341                    .into_iter()
3342                    .map(|p| ("object_type_id".to_owned(), p.to_string()))
3343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3344            ),
3345            _ => local_var_req_builder.query(&[(
3346                "object_type_id",
3347                &local_var_str
3348                    .into_iter()
3349                    .map(|p| p.to_string())
3350                    .collect::<Vec<String>>()
3351                    .join(",")
3352                    .to_string(),
3353            )]),
3354        };
3355    }
3356    if let Some(ref local_var_str) = object_type_id__n {
3357        local_var_req_builder = match "multi" {
3358            "multi" => local_var_req_builder.query(
3359                &local_var_str
3360                    .into_iter()
3361                    .map(|p| ("object_type_id__n".to_owned(), p.to_string()))
3362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3363            ),
3364            _ => local_var_req_builder.query(&[(
3365                "object_type_id__n",
3366                &local_var_str
3367                    .into_iter()
3368                    .map(|p| p.to_string())
3369                    .collect::<Vec<String>>()
3370                    .join(",")
3371                    .to_string(),
3372            )]),
3373        };
3374    }
3375    if let Some(ref local_var_str) = offset {
3376        local_var_req_builder =
3377            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3378    }
3379    if let Some(ref local_var_str) = ordering {
3380        local_var_req_builder =
3381            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3382    }
3383    if let Some(ref local_var_str) = q {
3384        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3385    }
3386    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3387        local_var_req_builder =
3388            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3389    }
3390    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3391        let local_var_key = local_var_apikey.key.clone();
3392        let local_var_value = match local_var_apikey.prefix {
3393            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3394            None => local_var_key,
3395        };
3396        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3397    };
3398
3399    let local_var_req = local_var_req_builder.build()?;
3400    let local_var_resp = local_var_client.execute(local_var_req).await?;
3401
3402    let local_var_status = local_var_resp.status();
3403    let local_var_content = local_var_resp.text().await?;
3404
3405    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3406        serde_json::from_str(&local_var_content).map_err(Error::from)
3407    } else {
3408        let local_var_entity: Option<PluginsBranchingChangesListError> =
3409            serde_json::from_str(&local_var_content).ok();
3410        let local_var_error = ResponseContent {
3411            status: local_var_status,
3412            content: local_var_content,
3413            entity: local_var_entity,
3414        };
3415        Err(Error::ResponseError(local_var_error))
3416    }
3417}
3418
3419/// Get a change diff object.
3420pub async fn plugins_branching_changes_retrieve(
3421    configuration: &configuration::Configuration,
3422    id: i32,
3423) -> Result<crate::models::ChangeDiff, Error<PluginsBranchingChangesRetrieveError>> {
3424    let local_var_configuration = configuration;
3425
3426    let local_var_client = &local_var_configuration.client;
3427
3428    let local_var_uri_str = format!(
3429        "{}/api/plugins/branching/changes/{id}/",
3430        local_var_configuration.base_path,
3431        id = id
3432    );
3433    let mut local_var_req_builder =
3434        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3435
3436    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3437        local_var_req_builder =
3438            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3439    }
3440    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3441        let local_var_key = local_var_apikey.key.clone();
3442        let local_var_value = match local_var_apikey.prefix {
3443            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3444            None => local_var_key,
3445        };
3446        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3447    };
3448
3449    let local_var_req = local_var_req_builder.build()?;
3450    let local_var_resp = local_var_client.execute(local_var_req).await?;
3451
3452    let local_var_status = local_var_resp.status();
3453    let local_var_content = local_var_resp.text().await?;
3454
3455    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3456        serde_json::from_str(&local_var_content).map_err(Error::from)
3457    } else {
3458        let local_var_entity: Option<PluginsBranchingChangesRetrieveError> =
3459            serde_json::from_str(&local_var_content).ok();
3460        let local_var_error = ResponseContent {
3461            status: local_var_status,
3462            content: local_var_content,
3463            entity: local_var_entity,
3464        };
3465        Err(Error::ResponseError(local_var_error))
3466    }
3467}
netbox_openapi/apis/plugins_api.rs

netbox_openapi/apis/
plugins_api.rs
