Skip to main content

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