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