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

netbox_openapi/apis/
wireless_api.rs
