nautobot_openapi/apis/
circuits_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
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 [`circuits_circuit_terminations_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CircuitsCircuitTerminationsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`circuits_circuit_terminations_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum CircuitsCircuitTerminationsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`circuits_circuit_terminations_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum CircuitsCircuitTerminationsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`circuits_circuit_terminations_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum CircuitsCircuitTerminationsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`circuits_circuit_terminations_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum CircuitsCircuitTerminationsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`circuits_circuit_terminations_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum CircuitsCircuitTerminationsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`circuits_circuit_terminations_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum CircuitsCircuitTerminationsNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`circuits_circuit_terminations_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum CircuitsCircuitTerminationsNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`circuits_circuit_terminations_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum CircuitsCircuitTerminationsPartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`circuits_circuit_terminations_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum CircuitsCircuitTerminationsRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`circuits_circuit_terminations_trace_retrieve`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum CircuitsCircuitTerminationsTraceRetrieveError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`circuits_circuit_terminations_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum CircuitsCircuitTerminationsUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`circuits_circuit_types_bulk_destroy`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum CircuitsCircuitTypesBulkDestroyError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`circuits_circuit_types_bulk_partial_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum CircuitsCircuitTypesBulkPartialUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`circuits_circuit_types_bulk_update`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum CircuitsCircuitTypesBulkUpdateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`circuits_circuit_types_create`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum CircuitsCircuitTypesCreateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`circuits_circuit_types_destroy`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum CircuitsCircuitTypesDestroyError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`circuits_circuit_types_list`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum CircuitsCircuitTypesListError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`circuits_circuit_types_notes_create`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum CircuitsCircuitTypesNotesCreateError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`circuits_circuit_types_notes_list`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum CircuitsCircuitTypesNotesListError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`circuits_circuit_types_partial_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum CircuitsCircuitTypesPartialUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`circuits_circuit_types_retrieve`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum CircuitsCircuitTypesRetrieveError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`circuits_circuit_types_update`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum CircuitsCircuitTypesUpdateError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`circuits_circuits_bulk_destroy`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum CircuitsCircuitsBulkDestroyError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`circuits_circuits_bulk_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum CircuitsCircuitsBulkPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`circuits_circuits_bulk_update`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum CircuitsCircuitsBulkUpdateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`circuits_circuits_create`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum CircuitsCircuitsCreateError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`circuits_circuits_destroy`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum CircuitsCircuitsDestroyError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`circuits_circuits_list`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum CircuitsCircuitsListError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`circuits_circuits_notes_create`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum CircuitsCircuitsNotesCreateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`circuits_circuits_notes_list`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum CircuitsCircuitsNotesListError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`circuits_circuits_partial_update`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum CircuitsCircuitsPartialUpdateError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`circuits_circuits_retrieve`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum CircuitsCircuitsRetrieveError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`circuits_circuits_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum CircuitsCircuitsUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`circuits_provider_networks_bulk_destroy`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum CircuitsProviderNetworksBulkDestroyError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`circuits_provider_networks_bulk_partial_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum CircuitsProviderNetworksBulkPartialUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`circuits_provider_networks_bulk_update`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum CircuitsProviderNetworksBulkUpdateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`circuits_provider_networks_create`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum CircuitsProviderNetworksCreateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`circuits_provider_networks_destroy`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum CircuitsProviderNetworksDestroyError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`circuits_provider_networks_list`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum CircuitsProviderNetworksListError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`circuits_provider_networks_notes_create`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum CircuitsProviderNetworksNotesCreateError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`circuits_provider_networks_notes_list`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum CircuitsProviderNetworksNotesListError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`circuits_provider_networks_partial_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum CircuitsProviderNetworksPartialUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`circuits_provider_networks_retrieve`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum CircuitsProviderNetworksRetrieveError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`circuits_provider_networks_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum CircuitsProviderNetworksUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`circuits_providers_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum CircuitsProvidersBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`circuits_providers_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum CircuitsProvidersBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`circuits_providers_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum CircuitsProvidersBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`circuits_providers_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum CircuitsProvidersCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`circuits_providers_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum CircuitsProvidersDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`circuits_providers_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum CircuitsProvidersListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`circuits_providers_notes_create`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum CircuitsProvidersNotesCreateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`circuits_providers_notes_list`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum CircuitsProvidersNotesListError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`circuits_providers_partial_update`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum CircuitsProvidersPartialUpdateError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`circuits_providers_retrieve`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum CircuitsProvidersRetrieveError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`circuits_providers_update`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum CircuitsProvidersUpdateError {
405    UnknownValue(serde_json::Value),
406}
407
408/// Destroy a list of circuit termination objects.
409pub async fn circuits_circuit_terminations_bulk_destroy(
410    configuration: &configuration::Configuration,
411    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
412    format: Option<&str>,
413) -> Result<(), Error<CircuitsCircuitTerminationsBulkDestroyError>> {
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        "{}/circuits/circuit-terminations/",
420        local_var_configuration.base_path
421    );
422    let mut local_var_req_builder =
423        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
424
425    if let Some(ref local_var_str) = format {
426        local_var_req_builder =
427            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
428    }
429    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
430        local_var_req_builder =
431            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
432    }
433    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
434        let local_var_key = local_var_apikey.key.clone();
435        let local_var_value = match local_var_apikey.prefix {
436            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
437            None => local_var_key,
438        };
439        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
440    };
441    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
442
443    let local_var_req = local_var_req_builder.build()?;
444    let local_var_resp = local_var_client.execute(local_var_req).await?;
445
446    let local_var_status = local_var_resp.status();
447    let local_var_content = local_var_resp.text().await?;
448
449    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
450        Ok(())
451    } else {
452        let local_var_entity: Option<CircuitsCircuitTerminationsBulkDestroyError> =
453            serde_json::from_str(&local_var_content).ok();
454        let local_var_error = ResponseContent {
455            status: local_var_status,
456            content: local_var_content,
457            entity: local_var_entity,
458        };
459        Err(Error::ResponseError(local_var_error))
460    }
461}
462
463/// Partial update a list of circuit termination objects.
464pub async fn circuits_circuit_terminations_bulk_partial_update(
465    configuration: &configuration::Configuration,
466    patched_bulk_writable_circuit_termination_request: Vec<
467        crate::models::PatchedBulkWritableCircuitTerminationRequest,
468    >,
469    format: Option<&str>,
470) -> Result<
471    Vec<crate::models::CircuitTermination>,
472    Error<CircuitsCircuitTerminationsBulkPartialUpdateError>,
473> {
474    let local_var_configuration = configuration;
475
476    let local_var_client = &local_var_configuration.client;
477
478    let local_var_uri_str = format!(
479        "{}/circuits/circuit-terminations/",
480        local_var_configuration.base_path
481    );
482    let mut local_var_req_builder =
483        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
484
485    if let Some(ref local_var_str) = format {
486        local_var_req_builder =
487            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
488    }
489    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
490        local_var_req_builder =
491            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
492    }
493    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
494        let local_var_key = local_var_apikey.key.clone();
495        let local_var_value = match local_var_apikey.prefix {
496            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
497            None => local_var_key,
498        };
499        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
500    };
501    local_var_req_builder =
502        local_var_req_builder.json(&patched_bulk_writable_circuit_termination_request);
503
504    let local_var_req = local_var_req_builder.build()?;
505    let local_var_resp = local_var_client.execute(local_var_req).await?;
506
507    let local_var_status = local_var_resp.status();
508    let local_var_content = local_var_resp.text().await?;
509
510    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
511        serde_json::from_str(&local_var_content).map_err(Error::from)
512    } else {
513        let local_var_entity: Option<CircuitsCircuitTerminationsBulkPartialUpdateError> =
514            serde_json::from_str(&local_var_content).ok();
515        let local_var_error = ResponseContent {
516            status: local_var_status,
517            content: local_var_content,
518            entity: local_var_entity,
519        };
520        Err(Error::ResponseError(local_var_error))
521    }
522}
523
524/// Update a list of circuit termination objects.
525pub async fn circuits_circuit_terminations_bulk_update(
526    configuration: &configuration::Configuration,
527    bulk_writable_circuit_termination_request: Vec<
528        crate::models::BulkWritableCircuitTerminationRequest,
529    >,
530    format: Option<&str>,
531) -> Result<Vec<crate::models::CircuitTermination>, Error<CircuitsCircuitTerminationsBulkUpdateError>>
532{
533    let local_var_configuration = configuration;
534
535    let local_var_client = &local_var_configuration.client;
536
537    let local_var_uri_str = format!(
538        "{}/circuits/circuit-terminations/",
539        local_var_configuration.base_path
540    );
541    let mut local_var_req_builder =
542        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
543
544    if let Some(ref local_var_str) = format {
545        local_var_req_builder =
546            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
547    }
548    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
549        local_var_req_builder =
550            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
551    }
552    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
553        let local_var_key = local_var_apikey.key.clone();
554        let local_var_value = match local_var_apikey.prefix {
555            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
556            None => local_var_key,
557        };
558        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
559    };
560    local_var_req_builder = local_var_req_builder.json(&bulk_writable_circuit_termination_request);
561
562    let local_var_req = local_var_req_builder.build()?;
563    let local_var_resp = local_var_client.execute(local_var_req).await?;
564
565    let local_var_status = local_var_resp.status();
566    let local_var_content = local_var_resp.text().await?;
567
568    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
569        serde_json::from_str(&local_var_content).map_err(Error::from)
570    } else {
571        let local_var_entity: Option<CircuitsCircuitTerminationsBulkUpdateError> =
572            serde_json::from_str(&local_var_content).ok();
573        let local_var_error = ResponseContent {
574            status: local_var_status,
575            content: local_var_content,
576            entity: local_var_entity,
577        };
578        Err(Error::ResponseError(local_var_error))
579    }
580}
581
582/// Create one or more circuit termination objects.
583pub async fn circuits_circuit_terminations_create(
584    configuration: &configuration::Configuration,
585    circuit_termination_request: crate::models::CircuitTerminationRequest,
586    format: Option<&str>,
587) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsCreateError>> {
588    let local_var_configuration = configuration;
589
590    let local_var_client = &local_var_configuration.client;
591
592    let local_var_uri_str = format!(
593        "{}/circuits/circuit-terminations/",
594        local_var_configuration.base_path
595    );
596    let mut local_var_req_builder =
597        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
598
599    if let Some(ref local_var_str) = format {
600        local_var_req_builder =
601            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
602    }
603    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
604        local_var_req_builder =
605            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
606    }
607    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
608        let local_var_key = local_var_apikey.key.clone();
609        let local_var_value = match local_var_apikey.prefix {
610            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
611            None => local_var_key,
612        };
613        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
614    };
615    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
616
617    let local_var_req = local_var_req_builder.build()?;
618    let local_var_resp = local_var_client.execute(local_var_req).await?;
619
620    let local_var_status = local_var_resp.status();
621    let local_var_content = local_var_resp.text().await?;
622
623    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
624        serde_json::from_str(&local_var_content).map_err(Error::from)
625    } else {
626        let local_var_entity: Option<CircuitsCircuitTerminationsCreateError> =
627            serde_json::from_str(&local_var_content).ok();
628        let local_var_error = ResponseContent {
629            status: local_var_status,
630            content: local_var_content,
631            entity: local_var_entity,
632        };
633        Err(Error::ResponseError(local_var_error))
634    }
635}
636
637/// Destroy a circuit termination object.
638pub async fn circuits_circuit_terminations_destroy(
639    configuration: &configuration::Configuration,
640    id: &str,
641    format: Option<&str>,
642) -> Result<(), Error<CircuitsCircuitTerminationsDestroyError>> {
643    let local_var_configuration = configuration;
644
645    let local_var_client = &local_var_configuration.client;
646
647    let local_var_uri_str = format!(
648        "{}/circuits/circuit-terminations/{id}/",
649        local_var_configuration.base_path,
650        id = crate::apis::urlencode(id)
651    );
652    let mut local_var_req_builder =
653        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
654
655    if let Some(ref local_var_str) = format {
656        local_var_req_builder =
657            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
658    }
659    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
660        local_var_req_builder =
661            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
662    }
663    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
664        let local_var_key = local_var_apikey.key.clone();
665        let local_var_value = match local_var_apikey.prefix {
666            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
667            None => local_var_key,
668        };
669        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
670    };
671
672    let local_var_req = local_var_req_builder.build()?;
673    let local_var_resp = local_var_client.execute(local_var_req).await?;
674
675    let local_var_status = local_var_resp.status();
676    let local_var_content = local_var_resp.text().await?;
677
678    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
679        Ok(())
680    } else {
681        let local_var_entity: Option<CircuitsCircuitTerminationsDestroyError> =
682            serde_json::from_str(&local_var_content).ok();
683        let local_var_error = ResponseContent {
684            status: local_var_status,
685            content: local_var_content,
686            entity: local_var_entity,
687        };
688        Err(Error::ResponseError(local_var_error))
689    }
690}
691
692/// Retrieve a list of circuit termination objects.
693pub async fn circuits_circuit_terminations_list(
694    configuration: &configuration::Configuration,
695    cable: Option<Vec<uuid::Uuid>>,
696    cable__isnull: Option<bool>,
697    cable__n: Option<Vec<uuid::Uuid>>,
698    circuit: Option<Vec<String>>,
699    circuit__n: Option<Vec<String>>,
700    cloud_network: Option<Vec<String>>,
701    cloud_network__isnull: Option<bool>,
702    cloud_network__n: Option<Vec<String>>,
703    connected: Option<bool>,
704    contacts: Option<Vec<String>>,
705    contacts__isnull: Option<bool>,
706    contacts__n: Option<Vec<String>>,
707    description: Option<Vec<String>>,
708    description__ic: Option<Vec<String>>,
709    description__ie: Option<Vec<String>>,
710    description__iew: Option<Vec<String>>,
711    description__ire: Option<Vec<String>>,
712    description__isw: Option<Vec<String>>,
713    description__n: Option<Vec<String>>,
714    description__nic: Option<Vec<String>>,
715    description__nie: Option<Vec<String>>,
716    description__niew: Option<Vec<String>>,
717    description__nire: Option<Vec<String>>,
718    description__nisw: Option<Vec<String>>,
719    description__nre: Option<Vec<String>>,
720    description__re: Option<Vec<String>>,
721    dynamic_groups: Option<Vec<String>>,
722    dynamic_groups__n: Option<Vec<String>>,
723    format: Option<&str>,
724    has_cable: Option<bool>,
725    id: Option<Vec<uuid::Uuid>>,
726    id__n: Option<Vec<uuid::Uuid>>,
727    limit: Option<i32>,
728    location: Option<Vec<String>>,
729    location__isnull: Option<bool>,
730    location__n: Option<Vec<String>>,
731    offset: Option<i32>,
732    port_speed: Option<Vec<i32>>,
733    port_speed__gt: Option<Vec<i32>>,
734    port_speed__gte: Option<Vec<i32>>,
735    port_speed__isnull: Option<bool>,
736    port_speed__lt: Option<Vec<i32>>,
737    port_speed__lte: Option<Vec<i32>>,
738    port_speed__n: Option<Vec<i32>>,
739    pp_info: Option<Vec<String>>,
740    pp_info__ic: Option<Vec<String>>,
741    pp_info__ie: Option<Vec<String>>,
742    pp_info__iew: Option<Vec<String>>,
743    pp_info__ire: Option<Vec<String>>,
744    pp_info__isw: Option<Vec<String>>,
745    pp_info__n: Option<Vec<String>>,
746    pp_info__nic: Option<Vec<String>>,
747    pp_info__nie: Option<Vec<String>>,
748    pp_info__niew: Option<Vec<String>>,
749    pp_info__nire: Option<Vec<String>>,
750    pp_info__nisw: Option<Vec<String>>,
751    pp_info__nre: Option<Vec<String>>,
752    pp_info__re: Option<Vec<String>>,
753    provider_network: Option<Vec<String>>,
754    provider_network__isnull: Option<bool>,
755    provider_network__n: Option<Vec<String>>,
756    q: Option<&str>,
757    sort: Option<&str>,
758    tags: Option<Vec<String>>,
759    tags__isnull: Option<bool>,
760    tags__n: Option<Vec<String>>,
761    teams: Option<Vec<String>>,
762    teams__isnull: Option<bool>,
763    teams__n: Option<Vec<String>>,
764    term_side: Option<Vec<String>>,
765    term_side__ic: Option<Vec<String>>,
766    term_side__ie: Option<Vec<String>>,
767    term_side__iew: Option<Vec<String>>,
768    term_side__ire: Option<Vec<String>>,
769    term_side__isw: Option<Vec<String>>,
770    term_side__n: Option<Vec<String>>,
771    term_side__nic: Option<Vec<String>>,
772    term_side__nie: Option<Vec<String>>,
773    term_side__niew: Option<Vec<String>>,
774    term_side__nire: Option<Vec<String>>,
775    term_side__nisw: Option<Vec<String>>,
776    term_side__nre: Option<Vec<String>>,
777    term_side__re: Option<Vec<String>>,
778    upstream_speed: Option<Vec<i32>>,
779    upstream_speed__gt: Option<Vec<i32>>,
780    upstream_speed__gte: Option<Vec<i32>>,
781    upstream_speed__isnull: Option<bool>,
782    upstream_speed__lt: Option<Vec<i32>>,
783    upstream_speed__lte: Option<Vec<i32>>,
784    upstream_speed__n: Option<Vec<i32>>,
785    xconnect_id: Option<Vec<String>>,
786    xconnect_id__ic: Option<Vec<String>>,
787    xconnect_id__ie: Option<Vec<String>>,
788    xconnect_id__iew: Option<Vec<String>>,
789    xconnect_id__ire: Option<Vec<String>>,
790    xconnect_id__isw: Option<Vec<String>>,
791    xconnect_id__n: Option<Vec<String>>,
792    xconnect_id__nic: Option<Vec<String>>,
793    xconnect_id__nie: Option<Vec<String>>,
794    xconnect_id__niew: Option<Vec<String>>,
795    xconnect_id__nire: Option<Vec<String>>,
796    xconnect_id__nisw: Option<Vec<String>>,
797    xconnect_id__nre: Option<Vec<String>>,
798    xconnect_id__re: Option<Vec<String>>,
799    depth: Option<i32>,
800    exclude_m2m: Option<bool>,
801) -> Result<
802    crate::models::PaginatedCircuitTerminationList,
803    Error<CircuitsCircuitTerminationsListError>,
804> {
805    let local_var_configuration = configuration;
806
807    let local_var_client = &local_var_configuration.client;
808
809    let local_var_uri_str = format!(
810        "{}/circuits/circuit-terminations/",
811        local_var_configuration.base_path
812    );
813    let mut local_var_req_builder =
814        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
815
816    if let Some(ref local_var_str) = cable {
817        local_var_req_builder = match "multi" {
818            "multi" => local_var_req_builder.query(
819                &local_var_str
820                    .into_iter()
821                    .map(|p| ("cable".to_owned(), p.to_string()))
822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
823            ),
824            _ => local_var_req_builder.query(&[(
825                "cable",
826                &local_var_str
827                    .into_iter()
828                    .map(|p| p.to_string())
829                    .collect::<Vec<String>>()
830                    .join(",")
831                    .to_string(),
832            )]),
833        };
834    }
835    if let Some(ref local_var_str) = cable__isnull {
836        local_var_req_builder =
837            local_var_req_builder.query(&[("cable__isnull", &local_var_str.to_string())]);
838    }
839    if let Some(ref local_var_str) = cable__n {
840        local_var_req_builder = match "multi" {
841            "multi" => local_var_req_builder.query(
842                &local_var_str
843                    .into_iter()
844                    .map(|p| ("cable__n".to_owned(), p.to_string()))
845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
846            ),
847            _ => local_var_req_builder.query(&[(
848                "cable__n",
849                &local_var_str
850                    .into_iter()
851                    .map(|p| p.to_string())
852                    .collect::<Vec<String>>()
853                    .join(",")
854                    .to_string(),
855            )]),
856        };
857    }
858    if let Some(ref local_var_str) = circuit {
859        local_var_req_builder = match "multi" {
860            "multi" => local_var_req_builder.query(
861                &local_var_str
862                    .into_iter()
863                    .map(|p| ("circuit".to_owned(), p.to_string()))
864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
865            ),
866            _ => local_var_req_builder.query(&[(
867                "circuit",
868                &local_var_str
869                    .into_iter()
870                    .map(|p| p.to_string())
871                    .collect::<Vec<String>>()
872                    .join(",")
873                    .to_string(),
874            )]),
875        };
876    }
877    if let Some(ref local_var_str) = circuit__n {
878        local_var_req_builder = match "multi" {
879            "multi" => local_var_req_builder.query(
880                &local_var_str
881                    .into_iter()
882                    .map(|p| ("circuit__n".to_owned(), p.to_string()))
883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
884            ),
885            _ => local_var_req_builder.query(&[(
886                "circuit__n",
887                &local_var_str
888                    .into_iter()
889                    .map(|p| p.to_string())
890                    .collect::<Vec<String>>()
891                    .join(",")
892                    .to_string(),
893            )]),
894        };
895    }
896    if let Some(ref local_var_str) = cloud_network {
897        local_var_req_builder = match "multi" {
898            "multi" => local_var_req_builder.query(
899                &local_var_str
900                    .into_iter()
901                    .map(|p| ("cloud_network".to_owned(), p.to_string()))
902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
903            ),
904            _ => local_var_req_builder.query(&[(
905                "cloud_network",
906                &local_var_str
907                    .into_iter()
908                    .map(|p| p.to_string())
909                    .collect::<Vec<String>>()
910                    .join(",")
911                    .to_string(),
912            )]),
913        };
914    }
915    if let Some(ref local_var_str) = cloud_network__isnull {
916        local_var_req_builder =
917            local_var_req_builder.query(&[("cloud_network__isnull", &local_var_str.to_string())]);
918    }
919    if let Some(ref local_var_str) = cloud_network__n {
920        local_var_req_builder = match "multi" {
921            "multi" => local_var_req_builder.query(
922                &local_var_str
923                    .into_iter()
924                    .map(|p| ("cloud_network__n".to_owned(), p.to_string()))
925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
926            ),
927            _ => local_var_req_builder.query(&[(
928                "cloud_network__n",
929                &local_var_str
930                    .into_iter()
931                    .map(|p| p.to_string())
932                    .collect::<Vec<String>>()
933                    .join(",")
934                    .to_string(),
935            )]),
936        };
937    }
938    if let Some(ref local_var_str) = connected {
939        local_var_req_builder =
940            local_var_req_builder.query(&[("connected", &local_var_str.to_string())]);
941    }
942    if let Some(ref local_var_str) = contacts {
943        local_var_req_builder = match "multi" {
944            "multi" => local_var_req_builder.query(
945                &local_var_str
946                    .into_iter()
947                    .map(|p| ("contacts".to_owned(), p.to_string()))
948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
949            ),
950            _ => local_var_req_builder.query(&[(
951                "contacts",
952                &local_var_str
953                    .into_iter()
954                    .map(|p| p.to_string())
955                    .collect::<Vec<String>>()
956                    .join(",")
957                    .to_string(),
958            )]),
959        };
960    }
961    if let Some(ref local_var_str) = contacts__isnull {
962        local_var_req_builder =
963            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
964    }
965    if let Some(ref local_var_str) = contacts__n {
966        local_var_req_builder = match "multi" {
967            "multi" => local_var_req_builder.query(
968                &local_var_str
969                    .into_iter()
970                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
972            ),
973            _ => local_var_req_builder.query(&[(
974                "contacts__n",
975                &local_var_str
976                    .into_iter()
977                    .map(|p| p.to_string())
978                    .collect::<Vec<String>>()
979                    .join(",")
980                    .to_string(),
981            )]),
982        };
983    }
984    if let Some(ref local_var_str) = description {
985        local_var_req_builder = match "multi" {
986            "multi" => local_var_req_builder.query(
987                &local_var_str
988                    .into_iter()
989                    .map(|p| ("description".to_owned(), p.to_string()))
990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
991            ),
992            _ => local_var_req_builder.query(&[(
993                "description",
994                &local_var_str
995                    .into_iter()
996                    .map(|p| p.to_string())
997                    .collect::<Vec<String>>()
998                    .join(",")
999                    .to_string(),
1000            )]),
1001        };
1002    }
1003    if let Some(ref local_var_str) = description__ic {
1004        local_var_req_builder = match "multi" {
1005            "multi" => local_var_req_builder.query(
1006                &local_var_str
1007                    .into_iter()
1008                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1010            ),
1011            _ => local_var_req_builder.query(&[(
1012                "description__ic",
1013                &local_var_str
1014                    .into_iter()
1015                    .map(|p| p.to_string())
1016                    .collect::<Vec<String>>()
1017                    .join(",")
1018                    .to_string(),
1019            )]),
1020        };
1021    }
1022    if let Some(ref local_var_str) = description__ie {
1023        local_var_req_builder = match "multi" {
1024            "multi" => local_var_req_builder.query(
1025                &local_var_str
1026                    .into_iter()
1027                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1029            ),
1030            _ => local_var_req_builder.query(&[(
1031                "description__ie",
1032                &local_var_str
1033                    .into_iter()
1034                    .map(|p| p.to_string())
1035                    .collect::<Vec<String>>()
1036                    .join(",")
1037                    .to_string(),
1038            )]),
1039        };
1040    }
1041    if let Some(ref local_var_str) = description__iew {
1042        local_var_req_builder = match "multi" {
1043            "multi" => local_var_req_builder.query(
1044                &local_var_str
1045                    .into_iter()
1046                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1048            ),
1049            _ => local_var_req_builder.query(&[(
1050                "description__iew",
1051                &local_var_str
1052                    .into_iter()
1053                    .map(|p| p.to_string())
1054                    .collect::<Vec<String>>()
1055                    .join(",")
1056                    .to_string(),
1057            )]),
1058        };
1059    }
1060    if let Some(ref local_var_str) = description__ire {
1061        local_var_req_builder = match "multi" {
1062            "multi" => local_var_req_builder.query(
1063                &local_var_str
1064                    .into_iter()
1065                    .map(|p| ("description__ire".to_owned(), p.to_string()))
1066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1067            ),
1068            _ => local_var_req_builder.query(&[(
1069                "description__ire",
1070                &local_var_str
1071                    .into_iter()
1072                    .map(|p| p.to_string())
1073                    .collect::<Vec<String>>()
1074                    .join(",")
1075                    .to_string(),
1076            )]),
1077        };
1078    }
1079    if let Some(ref local_var_str) = description__isw {
1080        local_var_req_builder = match "multi" {
1081            "multi" => local_var_req_builder.query(
1082                &local_var_str
1083                    .into_iter()
1084                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1086            ),
1087            _ => local_var_req_builder.query(&[(
1088                "description__isw",
1089                &local_var_str
1090                    .into_iter()
1091                    .map(|p| p.to_string())
1092                    .collect::<Vec<String>>()
1093                    .join(",")
1094                    .to_string(),
1095            )]),
1096        };
1097    }
1098    if let Some(ref local_var_str) = description__n {
1099        local_var_req_builder = match "multi" {
1100            "multi" => local_var_req_builder.query(
1101                &local_var_str
1102                    .into_iter()
1103                    .map(|p| ("description__n".to_owned(), p.to_string()))
1104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1105            ),
1106            _ => local_var_req_builder.query(&[(
1107                "description__n",
1108                &local_var_str
1109                    .into_iter()
1110                    .map(|p| p.to_string())
1111                    .collect::<Vec<String>>()
1112                    .join(",")
1113                    .to_string(),
1114            )]),
1115        };
1116    }
1117    if let Some(ref local_var_str) = description__nic {
1118        local_var_req_builder = match "multi" {
1119            "multi" => local_var_req_builder.query(
1120                &local_var_str
1121                    .into_iter()
1122                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1124            ),
1125            _ => local_var_req_builder.query(&[(
1126                "description__nic",
1127                &local_var_str
1128                    .into_iter()
1129                    .map(|p| p.to_string())
1130                    .collect::<Vec<String>>()
1131                    .join(",")
1132                    .to_string(),
1133            )]),
1134        };
1135    }
1136    if let Some(ref local_var_str) = description__nie {
1137        local_var_req_builder = match "multi" {
1138            "multi" => local_var_req_builder.query(
1139                &local_var_str
1140                    .into_iter()
1141                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1143            ),
1144            _ => local_var_req_builder.query(&[(
1145                "description__nie",
1146                &local_var_str
1147                    .into_iter()
1148                    .map(|p| p.to_string())
1149                    .collect::<Vec<String>>()
1150                    .join(",")
1151                    .to_string(),
1152            )]),
1153        };
1154    }
1155    if let Some(ref local_var_str) = description__niew {
1156        local_var_req_builder = match "multi" {
1157            "multi" => local_var_req_builder.query(
1158                &local_var_str
1159                    .into_iter()
1160                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1162            ),
1163            _ => local_var_req_builder.query(&[(
1164                "description__niew",
1165                &local_var_str
1166                    .into_iter()
1167                    .map(|p| p.to_string())
1168                    .collect::<Vec<String>>()
1169                    .join(",")
1170                    .to_string(),
1171            )]),
1172        };
1173    }
1174    if let Some(ref local_var_str) = description__nire {
1175        local_var_req_builder = match "multi" {
1176            "multi" => local_var_req_builder.query(
1177                &local_var_str
1178                    .into_iter()
1179                    .map(|p| ("description__nire".to_owned(), p.to_string()))
1180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1181            ),
1182            _ => local_var_req_builder.query(&[(
1183                "description__nire",
1184                &local_var_str
1185                    .into_iter()
1186                    .map(|p| p.to_string())
1187                    .collect::<Vec<String>>()
1188                    .join(",")
1189                    .to_string(),
1190            )]),
1191        };
1192    }
1193    if let Some(ref local_var_str) = description__nisw {
1194        local_var_req_builder = match "multi" {
1195            "multi" => local_var_req_builder.query(
1196                &local_var_str
1197                    .into_iter()
1198                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1200            ),
1201            _ => local_var_req_builder.query(&[(
1202                "description__nisw",
1203                &local_var_str
1204                    .into_iter()
1205                    .map(|p| p.to_string())
1206                    .collect::<Vec<String>>()
1207                    .join(",")
1208                    .to_string(),
1209            )]),
1210        };
1211    }
1212    if let Some(ref local_var_str) = description__nre {
1213        local_var_req_builder = match "multi" {
1214            "multi" => local_var_req_builder.query(
1215                &local_var_str
1216                    .into_iter()
1217                    .map(|p| ("description__nre".to_owned(), p.to_string()))
1218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1219            ),
1220            _ => local_var_req_builder.query(&[(
1221                "description__nre",
1222                &local_var_str
1223                    .into_iter()
1224                    .map(|p| p.to_string())
1225                    .collect::<Vec<String>>()
1226                    .join(",")
1227                    .to_string(),
1228            )]),
1229        };
1230    }
1231    if let Some(ref local_var_str) = description__re {
1232        local_var_req_builder = match "multi" {
1233            "multi" => local_var_req_builder.query(
1234                &local_var_str
1235                    .into_iter()
1236                    .map(|p| ("description__re".to_owned(), p.to_string()))
1237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1238            ),
1239            _ => local_var_req_builder.query(&[(
1240                "description__re",
1241                &local_var_str
1242                    .into_iter()
1243                    .map(|p| p.to_string())
1244                    .collect::<Vec<String>>()
1245                    .join(",")
1246                    .to_string(),
1247            )]),
1248        };
1249    }
1250    if let Some(ref local_var_str) = dynamic_groups {
1251        local_var_req_builder = match "multi" {
1252            "multi" => local_var_req_builder.query(
1253                &local_var_str
1254                    .into_iter()
1255                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
1256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1257            ),
1258            _ => local_var_req_builder.query(&[(
1259                "dynamic_groups",
1260                &local_var_str
1261                    .into_iter()
1262                    .map(|p| p.to_string())
1263                    .collect::<Vec<String>>()
1264                    .join(",")
1265                    .to_string(),
1266            )]),
1267        };
1268    }
1269    if let Some(ref local_var_str) = dynamic_groups__n {
1270        local_var_req_builder = match "multi" {
1271            "multi" => local_var_req_builder.query(
1272                &local_var_str
1273                    .into_iter()
1274                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
1275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1276            ),
1277            _ => local_var_req_builder.query(&[(
1278                "dynamic_groups__n",
1279                &local_var_str
1280                    .into_iter()
1281                    .map(|p| p.to_string())
1282                    .collect::<Vec<String>>()
1283                    .join(",")
1284                    .to_string(),
1285            )]),
1286        };
1287    }
1288    if let Some(ref local_var_str) = format {
1289        local_var_req_builder =
1290            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1291    }
1292    if let Some(ref local_var_str) = has_cable {
1293        local_var_req_builder =
1294            local_var_req_builder.query(&[("has_cable", &local_var_str.to_string())]);
1295    }
1296    if let Some(ref local_var_str) = id {
1297        local_var_req_builder = match "multi" {
1298            "multi" => local_var_req_builder.query(
1299                &local_var_str
1300                    .into_iter()
1301                    .map(|p| ("id".to_owned(), p.to_string()))
1302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1303            ),
1304            _ => local_var_req_builder.query(&[(
1305                "id",
1306                &local_var_str
1307                    .into_iter()
1308                    .map(|p| p.to_string())
1309                    .collect::<Vec<String>>()
1310                    .join(",")
1311                    .to_string(),
1312            )]),
1313        };
1314    }
1315    if let Some(ref local_var_str) = id__n {
1316        local_var_req_builder = match "multi" {
1317            "multi" => local_var_req_builder.query(
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| ("id__n".to_owned(), p.to_string()))
1321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1322            ),
1323            _ => local_var_req_builder.query(&[(
1324                "id__n",
1325                &local_var_str
1326                    .into_iter()
1327                    .map(|p| p.to_string())
1328                    .collect::<Vec<String>>()
1329                    .join(",")
1330                    .to_string(),
1331            )]),
1332        };
1333    }
1334    if let Some(ref local_var_str) = limit {
1335        local_var_req_builder =
1336            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1337    }
1338    if let Some(ref local_var_str) = location {
1339        local_var_req_builder = match "multi" {
1340            "multi" => local_var_req_builder.query(
1341                &local_var_str
1342                    .into_iter()
1343                    .map(|p| ("location".to_owned(), p.to_string()))
1344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1345            ),
1346            _ => local_var_req_builder.query(&[(
1347                "location",
1348                &local_var_str
1349                    .into_iter()
1350                    .map(|p| p.to_string())
1351                    .collect::<Vec<String>>()
1352                    .join(",")
1353                    .to_string(),
1354            )]),
1355        };
1356    }
1357    if let Some(ref local_var_str) = location__isnull {
1358        local_var_req_builder =
1359            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
1360    }
1361    if let Some(ref local_var_str) = location__n {
1362        local_var_req_builder = match "multi" {
1363            "multi" => local_var_req_builder.query(
1364                &local_var_str
1365                    .into_iter()
1366                    .map(|p| ("location__n".to_owned(), p.to_string()))
1367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1368            ),
1369            _ => local_var_req_builder.query(&[(
1370                "location__n",
1371                &local_var_str
1372                    .into_iter()
1373                    .map(|p| p.to_string())
1374                    .collect::<Vec<String>>()
1375                    .join(",")
1376                    .to_string(),
1377            )]),
1378        };
1379    }
1380    if let Some(ref local_var_str) = offset {
1381        local_var_req_builder =
1382            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1383    }
1384    if let Some(ref local_var_str) = port_speed {
1385        local_var_req_builder = match "multi" {
1386            "multi" => local_var_req_builder.query(
1387                &local_var_str
1388                    .into_iter()
1389                    .map(|p| ("port_speed".to_owned(), p.to_string()))
1390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1391            ),
1392            _ => local_var_req_builder.query(&[(
1393                "port_speed",
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) = port_speed__gt {
1404        local_var_req_builder = match "multi" {
1405            "multi" => local_var_req_builder.query(
1406                &local_var_str
1407                    .into_iter()
1408                    .map(|p| ("port_speed__gt".to_owned(), p.to_string()))
1409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1410            ),
1411            _ => local_var_req_builder.query(&[(
1412                "port_speed__gt",
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) = port_speed__gte {
1423        local_var_req_builder = match "multi" {
1424            "multi" => local_var_req_builder.query(
1425                &local_var_str
1426                    .into_iter()
1427                    .map(|p| ("port_speed__gte".to_owned(), p.to_string()))
1428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1429            ),
1430            _ => local_var_req_builder.query(&[(
1431                "port_speed__gte",
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) = port_speed__isnull {
1442        local_var_req_builder =
1443            local_var_req_builder.query(&[("port_speed__isnull", &local_var_str.to_string())]);
1444    }
1445    if let Some(ref local_var_str) = port_speed__lt {
1446        local_var_req_builder = match "multi" {
1447            "multi" => local_var_req_builder.query(
1448                &local_var_str
1449                    .into_iter()
1450                    .map(|p| ("port_speed__lt".to_owned(), p.to_string()))
1451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1452            ),
1453            _ => local_var_req_builder.query(&[(
1454                "port_speed__lt",
1455                &local_var_str
1456                    .into_iter()
1457                    .map(|p| p.to_string())
1458                    .collect::<Vec<String>>()
1459                    .join(",")
1460                    .to_string(),
1461            )]),
1462        };
1463    }
1464    if let Some(ref local_var_str) = port_speed__lte {
1465        local_var_req_builder = match "multi" {
1466            "multi" => local_var_req_builder.query(
1467                &local_var_str
1468                    .into_iter()
1469                    .map(|p| ("port_speed__lte".to_owned(), p.to_string()))
1470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1471            ),
1472            _ => local_var_req_builder.query(&[(
1473                "port_speed__lte",
1474                &local_var_str
1475                    .into_iter()
1476                    .map(|p| p.to_string())
1477                    .collect::<Vec<String>>()
1478                    .join(",")
1479                    .to_string(),
1480            )]),
1481        };
1482    }
1483    if let Some(ref local_var_str) = port_speed__n {
1484        local_var_req_builder = match "multi" {
1485            "multi" => local_var_req_builder.query(
1486                &local_var_str
1487                    .into_iter()
1488                    .map(|p| ("port_speed__n".to_owned(), p.to_string()))
1489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1490            ),
1491            _ => local_var_req_builder.query(&[(
1492                "port_speed__n",
1493                &local_var_str
1494                    .into_iter()
1495                    .map(|p| p.to_string())
1496                    .collect::<Vec<String>>()
1497                    .join(",")
1498                    .to_string(),
1499            )]),
1500        };
1501    }
1502    if let Some(ref local_var_str) = pp_info {
1503        local_var_req_builder = match "multi" {
1504            "multi" => local_var_req_builder.query(
1505                &local_var_str
1506                    .into_iter()
1507                    .map(|p| ("pp_info".to_owned(), p.to_string()))
1508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1509            ),
1510            _ => local_var_req_builder.query(&[(
1511                "pp_info",
1512                &local_var_str
1513                    .into_iter()
1514                    .map(|p| p.to_string())
1515                    .collect::<Vec<String>>()
1516                    .join(",")
1517                    .to_string(),
1518            )]),
1519        };
1520    }
1521    if let Some(ref local_var_str) = pp_info__ic {
1522        local_var_req_builder = match "multi" {
1523            "multi" => local_var_req_builder.query(
1524                &local_var_str
1525                    .into_iter()
1526                    .map(|p| ("pp_info__ic".to_owned(), p.to_string()))
1527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1528            ),
1529            _ => local_var_req_builder.query(&[(
1530                "pp_info__ic",
1531                &local_var_str
1532                    .into_iter()
1533                    .map(|p| p.to_string())
1534                    .collect::<Vec<String>>()
1535                    .join(",")
1536                    .to_string(),
1537            )]),
1538        };
1539    }
1540    if let Some(ref local_var_str) = pp_info__ie {
1541        local_var_req_builder = match "multi" {
1542            "multi" => local_var_req_builder.query(
1543                &local_var_str
1544                    .into_iter()
1545                    .map(|p| ("pp_info__ie".to_owned(), p.to_string()))
1546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1547            ),
1548            _ => local_var_req_builder.query(&[(
1549                "pp_info__ie",
1550                &local_var_str
1551                    .into_iter()
1552                    .map(|p| p.to_string())
1553                    .collect::<Vec<String>>()
1554                    .join(",")
1555                    .to_string(),
1556            )]),
1557        };
1558    }
1559    if let Some(ref local_var_str) = pp_info__iew {
1560        local_var_req_builder = match "multi" {
1561            "multi" => local_var_req_builder.query(
1562                &local_var_str
1563                    .into_iter()
1564                    .map(|p| ("pp_info__iew".to_owned(), p.to_string()))
1565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1566            ),
1567            _ => local_var_req_builder.query(&[(
1568                "pp_info__iew",
1569                &local_var_str
1570                    .into_iter()
1571                    .map(|p| p.to_string())
1572                    .collect::<Vec<String>>()
1573                    .join(",")
1574                    .to_string(),
1575            )]),
1576        };
1577    }
1578    if let Some(ref local_var_str) = pp_info__ire {
1579        local_var_req_builder = match "multi" {
1580            "multi" => local_var_req_builder.query(
1581                &local_var_str
1582                    .into_iter()
1583                    .map(|p| ("pp_info__ire".to_owned(), p.to_string()))
1584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1585            ),
1586            _ => local_var_req_builder.query(&[(
1587                "pp_info__ire",
1588                &local_var_str
1589                    .into_iter()
1590                    .map(|p| p.to_string())
1591                    .collect::<Vec<String>>()
1592                    .join(",")
1593                    .to_string(),
1594            )]),
1595        };
1596    }
1597    if let Some(ref local_var_str) = pp_info__isw {
1598        local_var_req_builder = match "multi" {
1599            "multi" => local_var_req_builder.query(
1600                &local_var_str
1601                    .into_iter()
1602                    .map(|p| ("pp_info__isw".to_owned(), p.to_string()))
1603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1604            ),
1605            _ => local_var_req_builder.query(&[(
1606                "pp_info__isw",
1607                &local_var_str
1608                    .into_iter()
1609                    .map(|p| p.to_string())
1610                    .collect::<Vec<String>>()
1611                    .join(",")
1612                    .to_string(),
1613            )]),
1614        };
1615    }
1616    if let Some(ref local_var_str) = pp_info__n {
1617        local_var_req_builder = match "multi" {
1618            "multi" => local_var_req_builder.query(
1619                &local_var_str
1620                    .into_iter()
1621                    .map(|p| ("pp_info__n".to_owned(), p.to_string()))
1622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1623            ),
1624            _ => local_var_req_builder.query(&[(
1625                "pp_info__n",
1626                &local_var_str
1627                    .into_iter()
1628                    .map(|p| p.to_string())
1629                    .collect::<Vec<String>>()
1630                    .join(",")
1631                    .to_string(),
1632            )]),
1633        };
1634    }
1635    if let Some(ref local_var_str) = pp_info__nic {
1636        local_var_req_builder = match "multi" {
1637            "multi" => local_var_req_builder.query(
1638                &local_var_str
1639                    .into_iter()
1640                    .map(|p| ("pp_info__nic".to_owned(), p.to_string()))
1641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1642            ),
1643            _ => local_var_req_builder.query(&[(
1644                "pp_info__nic",
1645                &local_var_str
1646                    .into_iter()
1647                    .map(|p| p.to_string())
1648                    .collect::<Vec<String>>()
1649                    .join(",")
1650                    .to_string(),
1651            )]),
1652        };
1653    }
1654    if let Some(ref local_var_str) = pp_info__nie {
1655        local_var_req_builder = match "multi" {
1656            "multi" => local_var_req_builder.query(
1657                &local_var_str
1658                    .into_iter()
1659                    .map(|p| ("pp_info__nie".to_owned(), p.to_string()))
1660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1661            ),
1662            _ => local_var_req_builder.query(&[(
1663                "pp_info__nie",
1664                &local_var_str
1665                    .into_iter()
1666                    .map(|p| p.to_string())
1667                    .collect::<Vec<String>>()
1668                    .join(",")
1669                    .to_string(),
1670            )]),
1671        };
1672    }
1673    if let Some(ref local_var_str) = pp_info__niew {
1674        local_var_req_builder = match "multi" {
1675            "multi" => local_var_req_builder.query(
1676                &local_var_str
1677                    .into_iter()
1678                    .map(|p| ("pp_info__niew".to_owned(), p.to_string()))
1679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1680            ),
1681            _ => local_var_req_builder.query(&[(
1682                "pp_info__niew",
1683                &local_var_str
1684                    .into_iter()
1685                    .map(|p| p.to_string())
1686                    .collect::<Vec<String>>()
1687                    .join(",")
1688                    .to_string(),
1689            )]),
1690        };
1691    }
1692    if let Some(ref local_var_str) = pp_info__nire {
1693        local_var_req_builder = match "multi" {
1694            "multi" => local_var_req_builder.query(
1695                &local_var_str
1696                    .into_iter()
1697                    .map(|p| ("pp_info__nire".to_owned(), p.to_string()))
1698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1699            ),
1700            _ => local_var_req_builder.query(&[(
1701                "pp_info__nire",
1702                &local_var_str
1703                    .into_iter()
1704                    .map(|p| p.to_string())
1705                    .collect::<Vec<String>>()
1706                    .join(",")
1707                    .to_string(),
1708            )]),
1709        };
1710    }
1711    if let Some(ref local_var_str) = pp_info__nisw {
1712        local_var_req_builder = match "multi" {
1713            "multi" => local_var_req_builder.query(
1714                &local_var_str
1715                    .into_iter()
1716                    .map(|p| ("pp_info__nisw".to_owned(), p.to_string()))
1717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1718            ),
1719            _ => local_var_req_builder.query(&[(
1720                "pp_info__nisw",
1721                &local_var_str
1722                    .into_iter()
1723                    .map(|p| p.to_string())
1724                    .collect::<Vec<String>>()
1725                    .join(",")
1726                    .to_string(),
1727            )]),
1728        };
1729    }
1730    if let Some(ref local_var_str) = pp_info__nre {
1731        local_var_req_builder = match "multi" {
1732            "multi" => local_var_req_builder.query(
1733                &local_var_str
1734                    .into_iter()
1735                    .map(|p| ("pp_info__nre".to_owned(), p.to_string()))
1736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1737            ),
1738            _ => local_var_req_builder.query(&[(
1739                "pp_info__nre",
1740                &local_var_str
1741                    .into_iter()
1742                    .map(|p| p.to_string())
1743                    .collect::<Vec<String>>()
1744                    .join(",")
1745                    .to_string(),
1746            )]),
1747        };
1748    }
1749    if let Some(ref local_var_str) = pp_info__re {
1750        local_var_req_builder = match "multi" {
1751            "multi" => local_var_req_builder.query(
1752                &local_var_str
1753                    .into_iter()
1754                    .map(|p| ("pp_info__re".to_owned(), p.to_string()))
1755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1756            ),
1757            _ => local_var_req_builder.query(&[(
1758                "pp_info__re",
1759                &local_var_str
1760                    .into_iter()
1761                    .map(|p| p.to_string())
1762                    .collect::<Vec<String>>()
1763                    .join(",")
1764                    .to_string(),
1765            )]),
1766        };
1767    }
1768    if let Some(ref local_var_str) = provider_network {
1769        local_var_req_builder = match "multi" {
1770            "multi" => local_var_req_builder.query(
1771                &local_var_str
1772                    .into_iter()
1773                    .map(|p| ("provider_network".to_owned(), p.to_string()))
1774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1775            ),
1776            _ => local_var_req_builder.query(&[(
1777                "provider_network",
1778                &local_var_str
1779                    .into_iter()
1780                    .map(|p| p.to_string())
1781                    .collect::<Vec<String>>()
1782                    .join(",")
1783                    .to_string(),
1784            )]),
1785        };
1786    }
1787    if let Some(ref local_var_str) = provider_network__isnull {
1788        local_var_req_builder = local_var_req_builder
1789            .query(&[("provider_network__isnull", &local_var_str.to_string())]);
1790    }
1791    if let Some(ref local_var_str) = provider_network__n {
1792        local_var_req_builder = match "multi" {
1793            "multi" => local_var_req_builder.query(
1794                &local_var_str
1795                    .into_iter()
1796                    .map(|p| ("provider_network__n".to_owned(), p.to_string()))
1797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1798            ),
1799            _ => local_var_req_builder.query(&[(
1800                "provider_network__n",
1801                &local_var_str
1802                    .into_iter()
1803                    .map(|p| p.to_string())
1804                    .collect::<Vec<String>>()
1805                    .join(",")
1806                    .to_string(),
1807            )]),
1808        };
1809    }
1810    if let Some(ref local_var_str) = q {
1811        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1812    }
1813    if let Some(ref local_var_str) = sort {
1814        local_var_req_builder =
1815            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
1816    }
1817    if let Some(ref local_var_str) = tags {
1818        local_var_req_builder = match "multi" {
1819            "multi" => local_var_req_builder.query(
1820                &local_var_str
1821                    .into_iter()
1822                    .map(|p| ("tags".to_owned(), p.to_string()))
1823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1824            ),
1825            _ => local_var_req_builder.query(&[(
1826                "tags",
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) = tags__isnull {
1837        local_var_req_builder =
1838            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
1839    }
1840    if let Some(ref local_var_str) = tags__n {
1841        local_var_req_builder = match "multi" {
1842            "multi" => local_var_req_builder.query(
1843                &local_var_str
1844                    .into_iter()
1845                    .map(|p| ("tags__n".to_owned(), p.to_string()))
1846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1847            ),
1848            _ => local_var_req_builder.query(&[(
1849                "tags__n",
1850                &local_var_str
1851                    .into_iter()
1852                    .map(|p| p.to_string())
1853                    .collect::<Vec<String>>()
1854                    .join(",")
1855                    .to_string(),
1856            )]),
1857        };
1858    }
1859    if let Some(ref local_var_str) = teams {
1860        local_var_req_builder = match "multi" {
1861            "multi" => local_var_req_builder.query(
1862                &local_var_str
1863                    .into_iter()
1864                    .map(|p| ("teams".to_owned(), p.to_string()))
1865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1866            ),
1867            _ => local_var_req_builder.query(&[(
1868                "teams",
1869                &local_var_str
1870                    .into_iter()
1871                    .map(|p| p.to_string())
1872                    .collect::<Vec<String>>()
1873                    .join(",")
1874                    .to_string(),
1875            )]),
1876        };
1877    }
1878    if let Some(ref local_var_str) = teams__isnull {
1879        local_var_req_builder =
1880            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
1881    }
1882    if let Some(ref local_var_str) = teams__n {
1883        local_var_req_builder = match "multi" {
1884            "multi" => local_var_req_builder.query(
1885                &local_var_str
1886                    .into_iter()
1887                    .map(|p| ("teams__n".to_owned(), p.to_string()))
1888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1889            ),
1890            _ => local_var_req_builder.query(&[(
1891                "teams__n",
1892                &local_var_str
1893                    .into_iter()
1894                    .map(|p| p.to_string())
1895                    .collect::<Vec<String>>()
1896                    .join(",")
1897                    .to_string(),
1898            )]),
1899        };
1900    }
1901    if let Some(ref local_var_str) = term_side {
1902        local_var_req_builder = match "multi" {
1903            "multi" => local_var_req_builder.query(
1904                &local_var_str
1905                    .into_iter()
1906                    .map(|p| ("term_side".to_owned(), p.to_string()))
1907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1908            ),
1909            _ => local_var_req_builder.query(&[(
1910                "term_side",
1911                &local_var_str
1912                    .into_iter()
1913                    .map(|p| p.to_string())
1914                    .collect::<Vec<String>>()
1915                    .join(",")
1916                    .to_string(),
1917            )]),
1918        };
1919    }
1920    if let Some(ref local_var_str) = term_side__ic {
1921        local_var_req_builder = match "multi" {
1922            "multi" => local_var_req_builder.query(
1923                &local_var_str
1924                    .into_iter()
1925                    .map(|p| ("term_side__ic".to_owned(), p.to_string()))
1926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1927            ),
1928            _ => local_var_req_builder.query(&[(
1929                "term_side__ic",
1930                &local_var_str
1931                    .into_iter()
1932                    .map(|p| p.to_string())
1933                    .collect::<Vec<String>>()
1934                    .join(",")
1935                    .to_string(),
1936            )]),
1937        };
1938    }
1939    if let Some(ref local_var_str) = term_side__ie {
1940        local_var_req_builder = match "multi" {
1941            "multi" => local_var_req_builder.query(
1942                &local_var_str
1943                    .into_iter()
1944                    .map(|p| ("term_side__ie".to_owned(), p.to_string()))
1945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1946            ),
1947            _ => local_var_req_builder.query(&[(
1948                "term_side__ie",
1949                &local_var_str
1950                    .into_iter()
1951                    .map(|p| p.to_string())
1952                    .collect::<Vec<String>>()
1953                    .join(",")
1954                    .to_string(),
1955            )]),
1956        };
1957    }
1958    if let Some(ref local_var_str) = term_side__iew {
1959        local_var_req_builder = match "multi" {
1960            "multi" => local_var_req_builder.query(
1961                &local_var_str
1962                    .into_iter()
1963                    .map(|p| ("term_side__iew".to_owned(), p.to_string()))
1964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1965            ),
1966            _ => local_var_req_builder.query(&[(
1967                "term_side__iew",
1968                &local_var_str
1969                    .into_iter()
1970                    .map(|p| p.to_string())
1971                    .collect::<Vec<String>>()
1972                    .join(",")
1973                    .to_string(),
1974            )]),
1975        };
1976    }
1977    if let Some(ref local_var_str) = term_side__ire {
1978        local_var_req_builder = match "multi" {
1979            "multi" => local_var_req_builder.query(
1980                &local_var_str
1981                    .into_iter()
1982                    .map(|p| ("term_side__ire".to_owned(), p.to_string()))
1983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1984            ),
1985            _ => local_var_req_builder.query(&[(
1986                "term_side__ire",
1987                &local_var_str
1988                    .into_iter()
1989                    .map(|p| p.to_string())
1990                    .collect::<Vec<String>>()
1991                    .join(",")
1992                    .to_string(),
1993            )]),
1994        };
1995    }
1996    if let Some(ref local_var_str) = term_side__isw {
1997        local_var_req_builder = match "multi" {
1998            "multi" => local_var_req_builder.query(
1999                &local_var_str
2000                    .into_iter()
2001                    .map(|p| ("term_side__isw".to_owned(), p.to_string()))
2002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2003            ),
2004            _ => local_var_req_builder.query(&[(
2005                "term_side__isw",
2006                &local_var_str
2007                    .into_iter()
2008                    .map(|p| p.to_string())
2009                    .collect::<Vec<String>>()
2010                    .join(",")
2011                    .to_string(),
2012            )]),
2013        };
2014    }
2015    if let Some(ref local_var_str) = term_side__n {
2016        local_var_req_builder = match "multi" {
2017            "multi" => local_var_req_builder.query(
2018                &local_var_str
2019                    .into_iter()
2020                    .map(|p| ("term_side__n".to_owned(), p.to_string()))
2021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2022            ),
2023            _ => local_var_req_builder.query(&[(
2024                "term_side__n",
2025                &local_var_str
2026                    .into_iter()
2027                    .map(|p| p.to_string())
2028                    .collect::<Vec<String>>()
2029                    .join(",")
2030                    .to_string(),
2031            )]),
2032        };
2033    }
2034    if let Some(ref local_var_str) = term_side__nic {
2035        local_var_req_builder = match "multi" {
2036            "multi" => local_var_req_builder.query(
2037                &local_var_str
2038                    .into_iter()
2039                    .map(|p| ("term_side__nic".to_owned(), p.to_string()))
2040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2041            ),
2042            _ => local_var_req_builder.query(&[(
2043                "term_side__nic",
2044                &local_var_str
2045                    .into_iter()
2046                    .map(|p| p.to_string())
2047                    .collect::<Vec<String>>()
2048                    .join(",")
2049                    .to_string(),
2050            )]),
2051        };
2052    }
2053    if let Some(ref local_var_str) = term_side__nie {
2054        local_var_req_builder = match "multi" {
2055            "multi" => local_var_req_builder.query(
2056                &local_var_str
2057                    .into_iter()
2058                    .map(|p| ("term_side__nie".to_owned(), p.to_string()))
2059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2060            ),
2061            _ => local_var_req_builder.query(&[(
2062                "term_side__nie",
2063                &local_var_str
2064                    .into_iter()
2065                    .map(|p| p.to_string())
2066                    .collect::<Vec<String>>()
2067                    .join(",")
2068                    .to_string(),
2069            )]),
2070        };
2071    }
2072    if let Some(ref local_var_str) = term_side__niew {
2073        local_var_req_builder = match "multi" {
2074            "multi" => local_var_req_builder.query(
2075                &local_var_str
2076                    .into_iter()
2077                    .map(|p| ("term_side__niew".to_owned(), p.to_string()))
2078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2079            ),
2080            _ => local_var_req_builder.query(&[(
2081                "term_side__niew",
2082                &local_var_str
2083                    .into_iter()
2084                    .map(|p| p.to_string())
2085                    .collect::<Vec<String>>()
2086                    .join(",")
2087                    .to_string(),
2088            )]),
2089        };
2090    }
2091    if let Some(ref local_var_str) = term_side__nire {
2092        local_var_req_builder = match "multi" {
2093            "multi" => local_var_req_builder.query(
2094                &local_var_str
2095                    .into_iter()
2096                    .map(|p| ("term_side__nire".to_owned(), p.to_string()))
2097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2098            ),
2099            _ => local_var_req_builder.query(&[(
2100                "term_side__nire",
2101                &local_var_str
2102                    .into_iter()
2103                    .map(|p| p.to_string())
2104                    .collect::<Vec<String>>()
2105                    .join(",")
2106                    .to_string(),
2107            )]),
2108        };
2109    }
2110    if let Some(ref local_var_str) = term_side__nisw {
2111        local_var_req_builder = match "multi" {
2112            "multi" => local_var_req_builder.query(
2113                &local_var_str
2114                    .into_iter()
2115                    .map(|p| ("term_side__nisw".to_owned(), p.to_string()))
2116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2117            ),
2118            _ => local_var_req_builder.query(&[(
2119                "term_side__nisw",
2120                &local_var_str
2121                    .into_iter()
2122                    .map(|p| p.to_string())
2123                    .collect::<Vec<String>>()
2124                    .join(",")
2125                    .to_string(),
2126            )]),
2127        };
2128    }
2129    if let Some(ref local_var_str) = term_side__nre {
2130        local_var_req_builder = match "multi" {
2131            "multi" => local_var_req_builder.query(
2132                &local_var_str
2133                    .into_iter()
2134                    .map(|p| ("term_side__nre".to_owned(), p.to_string()))
2135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2136            ),
2137            _ => local_var_req_builder.query(&[(
2138                "term_side__nre",
2139                &local_var_str
2140                    .into_iter()
2141                    .map(|p| p.to_string())
2142                    .collect::<Vec<String>>()
2143                    .join(",")
2144                    .to_string(),
2145            )]),
2146        };
2147    }
2148    if let Some(ref local_var_str) = term_side__re {
2149        local_var_req_builder = match "multi" {
2150            "multi" => local_var_req_builder.query(
2151                &local_var_str
2152                    .into_iter()
2153                    .map(|p| ("term_side__re".to_owned(), p.to_string()))
2154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2155            ),
2156            _ => local_var_req_builder.query(&[(
2157                "term_side__re",
2158                &local_var_str
2159                    .into_iter()
2160                    .map(|p| p.to_string())
2161                    .collect::<Vec<String>>()
2162                    .join(",")
2163                    .to_string(),
2164            )]),
2165        };
2166    }
2167    if let Some(ref local_var_str) = upstream_speed {
2168        local_var_req_builder = match "multi" {
2169            "multi" => local_var_req_builder.query(
2170                &local_var_str
2171                    .into_iter()
2172                    .map(|p| ("upstream_speed".to_owned(), p.to_string()))
2173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2174            ),
2175            _ => local_var_req_builder.query(&[(
2176                "upstream_speed",
2177                &local_var_str
2178                    .into_iter()
2179                    .map(|p| p.to_string())
2180                    .collect::<Vec<String>>()
2181                    .join(",")
2182                    .to_string(),
2183            )]),
2184        };
2185    }
2186    if let Some(ref local_var_str) = upstream_speed__gt {
2187        local_var_req_builder = match "multi" {
2188            "multi" => local_var_req_builder.query(
2189                &local_var_str
2190                    .into_iter()
2191                    .map(|p| ("upstream_speed__gt".to_owned(), p.to_string()))
2192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2193            ),
2194            _ => local_var_req_builder.query(&[(
2195                "upstream_speed__gt",
2196                &local_var_str
2197                    .into_iter()
2198                    .map(|p| p.to_string())
2199                    .collect::<Vec<String>>()
2200                    .join(",")
2201                    .to_string(),
2202            )]),
2203        };
2204    }
2205    if let Some(ref local_var_str) = upstream_speed__gte {
2206        local_var_req_builder = match "multi" {
2207            "multi" => local_var_req_builder.query(
2208                &local_var_str
2209                    .into_iter()
2210                    .map(|p| ("upstream_speed__gte".to_owned(), p.to_string()))
2211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2212            ),
2213            _ => local_var_req_builder.query(&[(
2214                "upstream_speed__gte",
2215                &local_var_str
2216                    .into_iter()
2217                    .map(|p| p.to_string())
2218                    .collect::<Vec<String>>()
2219                    .join(",")
2220                    .to_string(),
2221            )]),
2222        };
2223    }
2224    if let Some(ref local_var_str) = upstream_speed__isnull {
2225        local_var_req_builder =
2226            local_var_req_builder.query(&[("upstream_speed__isnull", &local_var_str.to_string())]);
2227    }
2228    if let Some(ref local_var_str) = upstream_speed__lt {
2229        local_var_req_builder = match "multi" {
2230            "multi" => local_var_req_builder.query(
2231                &local_var_str
2232                    .into_iter()
2233                    .map(|p| ("upstream_speed__lt".to_owned(), p.to_string()))
2234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2235            ),
2236            _ => local_var_req_builder.query(&[(
2237                "upstream_speed__lt",
2238                &local_var_str
2239                    .into_iter()
2240                    .map(|p| p.to_string())
2241                    .collect::<Vec<String>>()
2242                    .join(",")
2243                    .to_string(),
2244            )]),
2245        };
2246    }
2247    if let Some(ref local_var_str) = upstream_speed__lte {
2248        local_var_req_builder = match "multi" {
2249            "multi" => local_var_req_builder.query(
2250                &local_var_str
2251                    .into_iter()
2252                    .map(|p| ("upstream_speed__lte".to_owned(), p.to_string()))
2253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2254            ),
2255            _ => local_var_req_builder.query(&[(
2256                "upstream_speed__lte",
2257                &local_var_str
2258                    .into_iter()
2259                    .map(|p| p.to_string())
2260                    .collect::<Vec<String>>()
2261                    .join(",")
2262                    .to_string(),
2263            )]),
2264        };
2265    }
2266    if let Some(ref local_var_str) = upstream_speed__n {
2267        local_var_req_builder = match "multi" {
2268            "multi" => local_var_req_builder.query(
2269                &local_var_str
2270                    .into_iter()
2271                    .map(|p| ("upstream_speed__n".to_owned(), p.to_string()))
2272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2273            ),
2274            _ => local_var_req_builder.query(&[(
2275                "upstream_speed__n",
2276                &local_var_str
2277                    .into_iter()
2278                    .map(|p| p.to_string())
2279                    .collect::<Vec<String>>()
2280                    .join(",")
2281                    .to_string(),
2282            )]),
2283        };
2284    }
2285    if let Some(ref local_var_str) = xconnect_id {
2286        local_var_req_builder = match "multi" {
2287            "multi" => local_var_req_builder.query(
2288                &local_var_str
2289                    .into_iter()
2290                    .map(|p| ("xconnect_id".to_owned(), p.to_string()))
2291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2292            ),
2293            _ => local_var_req_builder.query(&[(
2294                "xconnect_id",
2295                &local_var_str
2296                    .into_iter()
2297                    .map(|p| p.to_string())
2298                    .collect::<Vec<String>>()
2299                    .join(",")
2300                    .to_string(),
2301            )]),
2302        };
2303    }
2304    if let Some(ref local_var_str) = xconnect_id__ic {
2305        local_var_req_builder = match "multi" {
2306            "multi" => local_var_req_builder.query(
2307                &local_var_str
2308                    .into_iter()
2309                    .map(|p| ("xconnect_id__ic".to_owned(), p.to_string()))
2310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2311            ),
2312            _ => local_var_req_builder.query(&[(
2313                "xconnect_id__ic",
2314                &local_var_str
2315                    .into_iter()
2316                    .map(|p| p.to_string())
2317                    .collect::<Vec<String>>()
2318                    .join(",")
2319                    .to_string(),
2320            )]),
2321        };
2322    }
2323    if let Some(ref local_var_str) = xconnect_id__ie {
2324        local_var_req_builder = match "multi" {
2325            "multi" => local_var_req_builder.query(
2326                &local_var_str
2327                    .into_iter()
2328                    .map(|p| ("xconnect_id__ie".to_owned(), p.to_string()))
2329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2330            ),
2331            _ => local_var_req_builder.query(&[(
2332                "xconnect_id__ie",
2333                &local_var_str
2334                    .into_iter()
2335                    .map(|p| p.to_string())
2336                    .collect::<Vec<String>>()
2337                    .join(",")
2338                    .to_string(),
2339            )]),
2340        };
2341    }
2342    if let Some(ref local_var_str) = xconnect_id__iew {
2343        local_var_req_builder = match "multi" {
2344            "multi" => local_var_req_builder.query(
2345                &local_var_str
2346                    .into_iter()
2347                    .map(|p| ("xconnect_id__iew".to_owned(), p.to_string()))
2348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2349            ),
2350            _ => local_var_req_builder.query(&[(
2351                "xconnect_id__iew",
2352                &local_var_str
2353                    .into_iter()
2354                    .map(|p| p.to_string())
2355                    .collect::<Vec<String>>()
2356                    .join(",")
2357                    .to_string(),
2358            )]),
2359        };
2360    }
2361    if let Some(ref local_var_str) = xconnect_id__ire {
2362        local_var_req_builder = match "multi" {
2363            "multi" => local_var_req_builder.query(
2364                &local_var_str
2365                    .into_iter()
2366                    .map(|p| ("xconnect_id__ire".to_owned(), p.to_string()))
2367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2368            ),
2369            _ => local_var_req_builder.query(&[(
2370                "xconnect_id__ire",
2371                &local_var_str
2372                    .into_iter()
2373                    .map(|p| p.to_string())
2374                    .collect::<Vec<String>>()
2375                    .join(",")
2376                    .to_string(),
2377            )]),
2378        };
2379    }
2380    if let Some(ref local_var_str) = xconnect_id__isw {
2381        local_var_req_builder = match "multi" {
2382            "multi" => local_var_req_builder.query(
2383                &local_var_str
2384                    .into_iter()
2385                    .map(|p| ("xconnect_id__isw".to_owned(), p.to_string()))
2386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2387            ),
2388            _ => local_var_req_builder.query(&[(
2389                "xconnect_id__isw",
2390                &local_var_str
2391                    .into_iter()
2392                    .map(|p| p.to_string())
2393                    .collect::<Vec<String>>()
2394                    .join(",")
2395                    .to_string(),
2396            )]),
2397        };
2398    }
2399    if let Some(ref local_var_str) = xconnect_id__n {
2400        local_var_req_builder = match "multi" {
2401            "multi" => local_var_req_builder.query(
2402                &local_var_str
2403                    .into_iter()
2404                    .map(|p| ("xconnect_id__n".to_owned(), p.to_string()))
2405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2406            ),
2407            _ => local_var_req_builder.query(&[(
2408                "xconnect_id__n",
2409                &local_var_str
2410                    .into_iter()
2411                    .map(|p| p.to_string())
2412                    .collect::<Vec<String>>()
2413                    .join(",")
2414                    .to_string(),
2415            )]),
2416        };
2417    }
2418    if let Some(ref local_var_str) = xconnect_id__nic {
2419        local_var_req_builder = match "multi" {
2420            "multi" => local_var_req_builder.query(
2421                &local_var_str
2422                    .into_iter()
2423                    .map(|p| ("xconnect_id__nic".to_owned(), p.to_string()))
2424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2425            ),
2426            _ => local_var_req_builder.query(&[(
2427                "xconnect_id__nic",
2428                &local_var_str
2429                    .into_iter()
2430                    .map(|p| p.to_string())
2431                    .collect::<Vec<String>>()
2432                    .join(",")
2433                    .to_string(),
2434            )]),
2435        };
2436    }
2437    if let Some(ref local_var_str) = xconnect_id__nie {
2438        local_var_req_builder = match "multi" {
2439            "multi" => local_var_req_builder.query(
2440                &local_var_str
2441                    .into_iter()
2442                    .map(|p| ("xconnect_id__nie".to_owned(), p.to_string()))
2443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2444            ),
2445            _ => local_var_req_builder.query(&[(
2446                "xconnect_id__nie",
2447                &local_var_str
2448                    .into_iter()
2449                    .map(|p| p.to_string())
2450                    .collect::<Vec<String>>()
2451                    .join(",")
2452                    .to_string(),
2453            )]),
2454        };
2455    }
2456    if let Some(ref local_var_str) = xconnect_id__niew {
2457        local_var_req_builder = match "multi" {
2458            "multi" => local_var_req_builder.query(
2459                &local_var_str
2460                    .into_iter()
2461                    .map(|p| ("xconnect_id__niew".to_owned(), p.to_string()))
2462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2463            ),
2464            _ => local_var_req_builder.query(&[(
2465                "xconnect_id__niew",
2466                &local_var_str
2467                    .into_iter()
2468                    .map(|p| p.to_string())
2469                    .collect::<Vec<String>>()
2470                    .join(",")
2471                    .to_string(),
2472            )]),
2473        };
2474    }
2475    if let Some(ref local_var_str) = xconnect_id__nire {
2476        local_var_req_builder = match "multi" {
2477            "multi" => local_var_req_builder.query(
2478                &local_var_str
2479                    .into_iter()
2480                    .map(|p| ("xconnect_id__nire".to_owned(), p.to_string()))
2481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2482            ),
2483            _ => local_var_req_builder.query(&[(
2484                "xconnect_id__nire",
2485                &local_var_str
2486                    .into_iter()
2487                    .map(|p| p.to_string())
2488                    .collect::<Vec<String>>()
2489                    .join(",")
2490                    .to_string(),
2491            )]),
2492        };
2493    }
2494    if let Some(ref local_var_str) = xconnect_id__nisw {
2495        local_var_req_builder = match "multi" {
2496            "multi" => local_var_req_builder.query(
2497                &local_var_str
2498                    .into_iter()
2499                    .map(|p| ("xconnect_id__nisw".to_owned(), p.to_string()))
2500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2501            ),
2502            _ => local_var_req_builder.query(&[(
2503                "xconnect_id__nisw",
2504                &local_var_str
2505                    .into_iter()
2506                    .map(|p| p.to_string())
2507                    .collect::<Vec<String>>()
2508                    .join(",")
2509                    .to_string(),
2510            )]),
2511        };
2512    }
2513    if let Some(ref local_var_str) = xconnect_id__nre {
2514        local_var_req_builder = match "multi" {
2515            "multi" => local_var_req_builder.query(
2516                &local_var_str
2517                    .into_iter()
2518                    .map(|p| ("xconnect_id__nre".to_owned(), p.to_string()))
2519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2520            ),
2521            _ => local_var_req_builder.query(&[(
2522                "xconnect_id__nre",
2523                &local_var_str
2524                    .into_iter()
2525                    .map(|p| p.to_string())
2526                    .collect::<Vec<String>>()
2527                    .join(",")
2528                    .to_string(),
2529            )]),
2530        };
2531    }
2532    if let Some(ref local_var_str) = xconnect_id__re {
2533        local_var_req_builder = match "multi" {
2534            "multi" => local_var_req_builder.query(
2535                &local_var_str
2536                    .into_iter()
2537                    .map(|p| ("xconnect_id__re".to_owned(), p.to_string()))
2538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2539            ),
2540            _ => local_var_req_builder.query(&[(
2541                "xconnect_id__re",
2542                &local_var_str
2543                    .into_iter()
2544                    .map(|p| p.to_string())
2545                    .collect::<Vec<String>>()
2546                    .join(",")
2547                    .to_string(),
2548            )]),
2549        };
2550    }
2551    if let Some(ref local_var_str) = depth {
2552        local_var_req_builder =
2553            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2554    }
2555    if let Some(ref local_var_str) = exclude_m2m {
2556        local_var_req_builder =
2557            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2558    }
2559    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2560        local_var_req_builder =
2561            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2562    }
2563    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2564        let local_var_key = local_var_apikey.key.clone();
2565        let local_var_value = match local_var_apikey.prefix {
2566            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2567            None => local_var_key,
2568        };
2569        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2570    };
2571
2572    let local_var_req = local_var_req_builder.build()?;
2573    let local_var_resp = local_var_client.execute(local_var_req).await?;
2574
2575    let local_var_status = local_var_resp.status();
2576    let local_var_content = local_var_resp.text().await?;
2577
2578    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2579        serde_json::from_str(&local_var_content).map_err(Error::from)
2580    } else {
2581        let local_var_entity: Option<CircuitsCircuitTerminationsListError> =
2582            serde_json::from_str(&local_var_content).ok();
2583        let local_var_error = ResponseContent {
2584            status: local_var_status,
2585            content: local_var_content,
2586            entity: local_var_entity,
2587        };
2588        Err(Error::ResponseError(local_var_error))
2589    }
2590}
2591
2592/// API methods for returning or creating notes on an object.
2593pub async fn circuits_circuit_terminations_notes_create(
2594    configuration: &configuration::Configuration,
2595    id: &str,
2596    note_input_request: crate::models::NoteInputRequest,
2597    format: Option<&str>,
2598) -> Result<crate::models::Note, Error<CircuitsCircuitTerminationsNotesCreateError>> {
2599    let local_var_configuration = configuration;
2600
2601    let local_var_client = &local_var_configuration.client;
2602
2603    let local_var_uri_str = format!(
2604        "{}/circuits/circuit-terminations/{id}/notes/",
2605        local_var_configuration.base_path,
2606        id = crate::apis::urlencode(id)
2607    );
2608    let mut local_var_req_builder =
2609        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2610
2611    if let Some(ref local_var_str) = format {
2612        local_var_req_builder =
2613            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2614    }
2615    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2616        local_var_req_builder =
2617            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2618    }
2619    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2620        let local_var_key = local_var_apikey.key.clone();
2621        let local_var_value = match local_var_apikey.prefix {
2622            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2623            None => local_var_key,
2624        };
2625        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2626    };
2627    local_var_req_builder = local_var_req_builder.json(&note_input_request);
2628
2629    let local_var_req = local_var_req_builder.build()?;
2630    let local_var_resp = local_var_client.execute(local_var_req).await?;
2631
2632    let local_var_status = local_var_resp.status();
2633    let local_var_content = local_var_resp.text().await?;
2634
2635    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2636        serde_json::from_str(&local_var_content).map_err(Error::from)
2637    } else {
2638        let local_var_entity: Option<CircuitsCircuitTerminationsNotesCreateError> =
2639            serde_json::from_str(&local_var_content).ok();
2640        let local_var_error = ResponseContent {
2641            status: local_var_status,
2642            content: local_var_content,
2643            entity: local_var_entity,
2644        };
2645        Err(Error::ResponseError(local_var_error))
2646    }
2647}
2648
2649/// API methods for returning or creating notes on an object.
2650pub async fn circuits_circuit_terminations_notes_list(
2651    configuration: &configuration::Configuration,
2652    id: &str,
2653    format: Option<&str>,
2654    limit: Option<i32>,
2655    offset: Option<i32>,
2656    depth: Option<i32>,
2657    exclude_m2m: Option<bool>,
2658) -> Result<crate::models::PaginatedNoteList, Error<CircuitsCircuitTerminationsNotesListError>> {
2659    let local_var_configuration = configuration;
2660
2661    let local_var_client = &local_var_configuration.client;
2662
2663    let local_var_uri_str = format!(
2664        "{}/circuits/circuit-terminations/{id}/notes/",
2665        local_var_configuration.base_path,
2666        id = crate::apis::urlencode(id)
2667    );
2668    let mut local_var_req_builder =
2669        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2670
2671    if let Some(ref local_var_str) = format {
2672        local_var_req_builder =
2673            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2674    }
2675    if let Some(ref local_var_str) = limit {
2676        local_var_req_builder =
2677            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
2678    }
2679    if let Some(ref local_var_str) = offset {
2680        local_var_req_builder =
2681            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2682    }
2683    if let Some(ref local_var_str) = depth {
2684        local_var_req_builder =
2685            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2686    }
2687    if let Some(ref local_var_str) = exclude_m2m {
2688        local_var_req_builder =
2689            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2690    }
2691    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2692        local_var_req_builder =
2693            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2694    }
2695    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2696        let local_var_key = local_var_apikey.key.clone();
2697        let local_var_value = match local_var_apikey.prefix {
2698            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2699            None => local_var_key,
2700        };
2701        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2702    };
2703
2704    let local_var_req = local_var_req_builder.build()?;
2705    let local_var_resp = local_var_client.execute(local_var_req).await?;
2706
2707    let local_var_status = local_var_resp.status();
2708    let local_var_content = local_var_resp.text().await?;
2709
2710    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2711        serde_json::from_str(&local_var_content).map_err(Error::from)
2712    } else {
2713        let local_var_entity: Option<CircuitsCircuitTerminationsNotesListError> =
2714            serde_json::from_str(&local_var_content).ok();
2715        let local_var_error = ResponseContent {
2716            status: local_var_status,
2717            content: local_var_content,
2718            entity: local_var_entity,
2719        };
2720        Err(Error::ResponseError(local_var_error))
2721    }
2722}
2723
2724/// Partial update a circuit termination object.
2725pub async fn circuits_circuit_terminations_partial_update(
2726    configuration: &configuration::Configuration,
2727    id: &str,
2728    format: Option<&str>,
2729    patched_circuit_termination_request: Option<crate::models::PatchedCircuitTerminationRequest>,
2730) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsPartialUpdateError>>
2731{
2732    let local_var_configuration = configuration;
2733
2734    let local_var_client = &local_var_configuration.client;
2735
2736    let local_var_uri_str = format!(
2737        "{}/circuits/circuit-terminations/{id}/",
2738        local_var_configuration.base_path,
2739        id = crate::apis::urlencode(id)
2740    );
2741    let mut local_var_req_builder =
2742        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2743
2744    if let Some(ref local_var_str) = format {
2745        local_var_req_builder =
2746            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2747    }
2748    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2749        local_var_req_builder =
2750            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2751    }
2752    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2753        let local_var_key = local_var_apikey.key.clone();
2754        let local_var_value = match local_var_apikey.prefix {
2755            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2756            None => local_var_key,
2757        };
2758        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2759    };
2760    local_var_req_builder = local_var_req_builder.json(&patched_circuit_termination_request);
2761
2762    let local_var_req = local_var_req_builder.build()?;
2763    let local_var_resp = local_var_client.execute(local_var_req).await?;
2764
2765    let local_var_status = local_var_resp.status();
2766    let local_var_content = local_var_resp.text().await?;
2767
2768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2769        serde_json::from_str(&local_var_content).map_err(Error::from)
2770    } else {
2771        let local_var_entity: Option<CircuitsCircuitTerminationsPartialUpdateError> =
2772            serde_json::from_str(&local_var_content).ok();
2773        let local_var_error = ResponseContent {
2774            status: local_var_status,
2775            content: local_var_content,
2776            entity: local_var_entity,
2777        };
2778        Err(Error::ResponseError(local_var_error))
2779    }
2780}
2781
2782/// Retrieve a circuit termination object.
2783pub async fn circuits_circuit_terminations_retrieve(
2784    configuration: &configuration::Configuration,
2785    id: &str,
2786    format: Option<&str>,
2787    depth: Option<i32>,
2788    exclude_m2m: Option<bool>,
2789) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsRetrieveError>> {
2790    let local_var_configuration = configuration;
2791
2792    let local_var_client = &local_var_configuration.client;
2793
2794    let local_var_uri_str = format!(
2795        "{}/circuits/circuit-terminations/{id}/",
2796        local_var_configuration.base_path,
2797        id = crate::apis::urlencode(id)
2798    );
2799    let mut local_var_req_builder =
2800        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2801
2802    if let Some(ref local_var_str) = format {
2803        local_var_req_builder =
2804            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2805    }
2806    if let Some(ref local_var_str) = depth {
2807        local_var_req_builder =
2808            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2809    }
2810    if let Some(ref local_var_str) = exclude_m2m {
2811        local_var_req_builder =
2812            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2813    }
2814    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2815        local_var_req_builder =
2816            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2817    }
2818    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2819        let local_var_key = local_var_apikey.key.clone();
2820        let local_var_value = match local_var_apikey.prefix {
2821            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2822            None => local_var_key,
2823        };
2824        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2825    };
2826
2827    let local_var_req = local_var_req_builder.build()?;
2828    let local_var_resp = local_var_client.execute(local_var_req).await?;
2829
2830    let local_var_status = local_var_resp.status();
2831    let local_var_content = local_var_resp.text().await?;
2832
2833    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2834        serde_json::from_str(&local_var_content).map_err(Error::from)
2835    } else {
2836        let local_var_entity: Option<CircuitsCircuitTerminationsRetrieveError> =
2837            serde_json::from_str(&local_var_content).ok();
2838        let local_var_error = ResponseContent {
2839            status: local_var_status,
2840            content: local_var_content,
2841            entity: local_var_entity,
2842        };
2843        Err(Error::ResponseError(local_var_error))
2844    }
2845}
2846
2847/// Trace a complete cable path and return each segment as a three-tuple of (termination, cable, termination).
2848pub async fn circuits_circuit_terminations_trace_retrieve(
2849    configuration: &configuration::Configuration,
2850    id: &str,
2851    format: Option<&str>,
2852    depth: Option<i32>,
2853    exclude_m2m: Option<bool>,
2854) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsTraceRetrieveError>>
2855{
2856    let local_var_configuration = configuration;
2857
2858    let local_var_client = &local_var_configuration.client;
2859
2860    let local_var_uri_str = format!(
2861        "{}/circuits/circuit-terminations/{id}/trace/",
2862        local_var_configuration.base_path,
2863        id = crate::apis::urlencode(id)
2864    );
2865    let mut local_var_req_builder =
2866        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2867
2868    if let Some(ref local_var_str) = format {
2869        local_var_req_builder =
2870            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2871    }
2872    if let Some(ref local_var_str) = depth {
2873        local_var_req_builder =
2874            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2875    }
2876    if let Some(ref local_var_str) = exclude_m2m {
2877        local_var_req_builder =
2878            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2879    }
2880    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2881        local_var_req_builder =
2882            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2883    }
2884    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2885        let local_var_key = local_var_apikey.key.clone();
2886        let local_var_value = match local_var_apikey.prefix {
2887            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2888            None => local_var_key,
2889        };
2890        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2891    };
2892
2893    let local_var_req = local_var_req_builder.build()?;
2894    let local_var_resp = local_var_client.execute(local_var_req).await?;
2895
2896    let local_var_status = local_var_resp.status();
2897    let local_var_content = local_var_resp.text().await?;
2898
2899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2900        serde_json::from_str(&local_var_content).map_err(Error::from)
2901    } else {
2902        let local_var_entity: Option<CircuitsCircuitTerminationsTraceRetrieveError> =
2903            serde_json::from_str(&local_var_content).ok();
2904        let local_var_error = ResponseContent {
2905            status: local_var_status,
2906            content: local_var_content,
2907            entity: local_var_entity,
2908        };
2909        Err(Error::ResponseError(local_var_error))
2910    }
2911}
2912
2913/// Update a circuit termination object.
2914pub async fn circuits_circuit_terminations_update(
2915    configuration: &configuration::Configuration,
2916    id: &str,
2917    circuit_termination_request: crate::models::CircuitTerminationRequest,
2918    format: Option<&str>,
2919) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsUpdateError>> {
2920    let local_var_configuration = configuration;
2921
2922    let local_var_client = &local_var_configuration.client;
2923
2924    let local_var_uri_str = format!(
2925        "{}/circuits/circuit-terminations/{id}/",
2926        local_var_configuration.base_path,
2927        id = crate::apis::urlencode(id)
2928    );
2929    let mut local_var_req_builder =
2930        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2931
2932    if let Some(ref local_var_str) = format {
2933        local_var_req_builder =
2934            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2935    }
2936    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2937        local_var_req_builder =
2938            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2939    }
2940    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2941        let local_var_key = local_var_apikey.key.clone();
2942        let local_var_value = match local_var_apikey.prefix {
2943            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2944            None => local_var_key,
2945        };
2946        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2947    };
2948    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
2949
2950    let local_var_req = local_var_req_builder.build()?;
2951    let local_var_resp = local_var_client.execute(local_var_req).await?;
2952
2953    let local_var_status = local_var_resp.status();
2954    let local_var_content = local_var_resp.text().await?;
2955
2956    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2957        serde_json::from_str(&local_var_content).map_err(Error::from)
2958    } else {
2959        let local_var_entity: Option<CircuitsCircuitTerminationsUpdateError> =
2960            serde_json::from_str(&local_var_content).ok();
2961        let local_var_error = ResponseContent {
2962            status: local_var_status,
2963            content: local_var_content,
2964            entity: local_var_entity,
2965        };
2966        Err(Error::ResponseError(local_var_error))
2967    }
2968}
2969
2970/// Destroy a list of circuit type objects.
2971pub async fn circuits_circuit_types_bulk_destroy(
2972    configuration: &configuration::Configuration,
2973    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
2974    format: Option<&str>,
2975) -> Result<(), Error<CircuitsCircuitTypesBulkDestroyError>> {
2976    let local_var_configuration = configuration;
2977
2978    let local_var_client = &local_var_configuration.client;
2979
2980    let local_var_uri_str = format!(
2981        "{}/circuits/circuit-types/",
2982        local_var_configuration.base_path
2983    );
2984    let mut local_var_req_builder =
2985        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2986
2987    if let Some(ref local_var_str) = format {
2988        local_var_req_builder =
2989            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2990    }
2991    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2992        local_var_req_builder =
2993            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2994    }
2995    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2996        let local_var_key = local_var_apikey.key.clone();
2997        let local_var_value = match local_var_apikey.prefix {
2998            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2999            None => local_var_key,
3000        };
3001        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3002    };
3003    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
3004
3005    let local_var_req = local_var_req_builder.build()?;
3006    let local_var_resp = local_var_client.execute(local_var_req).await?;
3007
3008    let local_var_status = local_var_resp.status();
3009    let local_var_content = local_var_resp.text().await?;
3010
3011    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3012        Ok(())
3013    } else {
3014        let local_var_entity: Option<CircuitsCircuitTypesBulkDestroyError> =
3015            serde_json::from_str(&local_var_content).ok();
3016        let local_var_error = ResponseContent {
3017            status: local_var_status,
3018            content: local_var_content,
3019            entity: local_var_entity,
3020        };
3021        Err(Error::ResponseError(local_var_error))
3022    }
3023}
3024
3025/// Partial update a list of circuit type objects.
3026pub async fn circuits_circuit_types_bulk_partial_update(
3027    configuration: &configuration::Configuration,
3028    patched_bulk_writable_circuit_type_request: Vec<
3029        crate::models::PatchedBulkWritableCircuitTypeRequest,
3030    >,
3031    format: Option<&str>,
3032) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkPartialUpdateError>> {
3033    let local_var_configuration = configuration;
3034
3035    let local_var_client = &local_var_configuration.client;
3036
3037    let local_var_uri_str = format!(
3038        "{}/circuits/circuit-types/",
3039        local_var_configuration.base_path
3040    );
3041    let mut local_var_req_builder =
3042        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3043
3044    if let Some(ref local_var_str) = format {
3045        local_var_req_builder =
3046            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3047    }
3048    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3049        local_var_req_builder =
3050            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3051    }
3052    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3053        let local_var_key = local_var_apikey.key.clone();
3054        let local_var_value = match local_var_apikey.prefix {
3055            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3056            None => local_var_key,
3057        };
3058        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3059    };
3060    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_circuit_type_request);
3061
3062    let local_var_req = local_var_req_builder.build()?;
3063    let local_var_resp = local_var_client.execute(local_var_req).await?;
3064
3065    let local_var_status = local_var_resp.status();
3066    let local_var_content = local_var_resp.text().await?;
3067
3068    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3069        serde_json::from_str(&local_var_content).map_err(Error::from)
3070    } else {
3071        let local_var_entity: Option<CircuitsCircuitTypesBulkPartialUpdateError> =
3072            serde_json::from_str(&local_var_content).ok();
3073        let local_var_error = ResponseContent {
3074            status: local_var_status,
3075            content: local_var_content,
3076            entity: local_var_entity,
3077        };
3078        Err(Error::ResponseError(local_var_error))
3079    }
3080}
3081
3082/// Update a list of circuit type objects.
3083pub async fn circuits_circuit_types_bulk_update(
3084    configuration: &configuration::Configuration,
3085    bulk_writable_circuit_type_request: Vec<crate::models::BulkWritableCircuitTypeRequest>,
3086    format: Option<&str>,
3087) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkUpdateError>> {
3088    let local_var_configuration = configuration;
3089
3090    let local_var_client = &local_var_configuration.client;
3091
3092    let local_var_uri_str = format!(
3093        "{}/circuits/circuit-types/",
3094        local_var_configuration.base_path
3095    );
3096    let mut local_var_req_builder =
3097        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3098
3099    if let Some(ref local_var_str) = format {
3100        local_var_req_builder =
3101            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3102    }
3103    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3104        local_var_req_builder =
3105            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3106    }
3107    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3108        let local_var_key = local_var_apikey.key.clone();
3109        let local_var_value = match local_var_apikey.prefix {
3110            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3111            None => local_var_key,
3112        };
3113        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3114    };
3115    local_var_req_builder = local_var_req_builder.json(&bulk_writable_circuit_type_request);
3116
3117    let local_var_req = local_var_req_builder.build()?;
3118    let local_var_resp = local_var_client.execute(local_var_req).await?;
3119
3120    let local_var_status = local_var_resp.status();
3121    let local_var_content = local_var_resp.text().await?;
3122
3123    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3124        serde_json::from_str(&local_var_content).map_err(Error::from)
3125    } else {
3126        let local_var_entity: Option<CircuitsCircuitTypesBulkUpdateError> =
3127            serde_json::from_str(&local_var_content).ok();
3128        let local_var_error = ResponseContent {
3129            status: local_var_status,
3130            content: local_var_content,
3131            entity: local_var_entity,
3132        };
3133        Err(Error::ResponseError(local_var_error))
3134    }
3135}
3136
3137/// Create one or more circuit type objects.
3138pub async fn circuits_circuit_types_create(
3139    configuration: &configuration::Configuration,
3140    circuit_type_request: crate::models::CircuitTypeRequest,
3141    format: Option<&str>,
3142) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesCreateError>> {
3143    let local_var_configuration = configuration;
3144
3145    let local_var_client = &local_var_configuration.client;
3146
3147    let local_var_uri_str = format!(
3148        "{}/circuits/circuit-types/",
3149        local_var_configuration.base_path
3150    );
3151    let mut local_var_req_builder =
3152        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3153
3154    if let Some(ref local_var_str) = format {
3155        local_var_req_builder =
3156            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3157    }
3158    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3159        local_var_req_builder =
3160            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3161    }
3162    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3163        let local_var_key = local_var_apikey.key.clone();
3164        let local_var_value = match local_var_apikey.prefix {
3165            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3166            None => local_var_key,
3167        };
3168        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3169    };
3170    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
3171
3172    let local_var_req = local_var_req_builder.build()?;
3173    let local_var_resp = local_var_client.execute(local_var_req).await?;
3174
3175    let local_var_status = local_var_resp.status();
3176    let local_var_content = local_var_resp.text().await?;
3177
3178    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3179        serde_json::from_str(&local_var_content).map_err(Error::from)
3180    } else {
3181        let local_var_entity: Option<CircuitsCircuitTypesCreateError> =
3182            serde_json::from_str(&local_var_content).ok();
3183        let local_var_error = ResponseContent {
3184            status: local_var_status,
3185            content: local_var_content,
3186            entity: local_var_entity,
3187        };
3188        Err(Error::ResponseError(local_var_error))
3189    }
3190}
3191
3192/// Destroy a circuit type object.
3193pub async fn circuits_circuit_types_destroy(
3194    configuration: &configuration::Configuration,
3195    id: &str,
3196    format: Option<&str>,
3197) -> Result<(), Error<CircuitsCircuitTypesDestroyError>> {
3198    let local_var_configuration = configuration;
3199
3200    let local_var_client = &local_var_configuration.client;
3201
3202    let local_var_uri_str = format!(
3203        "{}/circuits/circuit-types/{id}/",
3204        local_var_configuration.base_path,
3205        id = crate::apis::urlencode(id)
3206    );
3207    let mut local_var_req_builder =
3208        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3209
3210    if let Some(ref local_var_str) = format {
3211        local_var_req_builder =
3212            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3213    }
3214    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3215        local_var_req_builder =
3216            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3217    }
3218    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3219        let local_var_key = local_var_apikey.key.clone();
3220        let local_var_value = match local_var_apikey.prefix {
3221            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3222            None => local_var_key,
3223        };
3224        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3225    };
3226
3227    let local_var_req = local_var_req_builder.build()?;
3228    let local_var_resp = local_var_client.execute(local_var_req).await?;
3229
3230    let local_var_status = local_var_resp.status();
3231    let local_var_content = local_var_resp.text().await?;
3232
3233    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3234        Ok(())
3235    } else {
3236        let local_var_entity: Option<CircuitsCircuitTypesDestroyError> =
3237            serde_json::from_str(&local_var_content).ok();
3238        let local_var_error = ResponseContent {
3239            status: local_var_status,
3240            content: local_var_content,
3241            entity: local_var_entity,
3242        };
3243        Err(Error::ResponseError(local_var_error))
3244    }
3245}
3246
3247/// Retrieve a list of circuit type objects.
3248pub async fn circuits_circuit_types_list(
3249    configuration: &configuration::Configuration,
3250    contacts: Option<Vec<String>>,
3251    contacts__isnull: Option<bool>,
3252    contacts__n: Option<Vec<String>>,
3253    created: Option<Vec<String>>,
3254    created__gt: Option<Vec<String>>,
3255    created__gte: Option<Vec<String>>,
3256    created__isnull: Option<bool>,
3257    created__lt: Option<Vec<String>>,
3258    created__lte: Option<Vec<String>>,
3259    created__n: Option<Vec<String>>,
3260    description: Option<Vec<String>>,
3261    description__ic: Option<Vec<String>>,
3262    description__ie: Option<Vec<String>>,
3263    description__iew: Option<Vec<String>>,
3264    description__ire: Option<Vec<String>>,
3265    description__isw: Option<Vec<String>>,
3266    description__n: Option<Vec<String>>,
3267    description__nic: Option<Vec<String>>,
3268    description__nie: Option<Vec<String>>,
3269    description__niew: Option<Vec<String>>,
3270    description__nire: Option<Vec<String>>,
3271    description__nisw: Option<Vec<String>>,
3272    description__nre: Option<Vec<String>>,
3273    description__re: Option<Vec<String>>,
3274    dynamic_groups: Option<Vec<String>>,
3275    dynamic_groups__n: Option<Vec<String>>,
3276    format: Option<&str>,
3277    id: Option<Vec<uuid::Uuid>>,
3278    id__n: Option<Vec<uuid::Uuid>>,
3279    last_updated: Option<Vec<String>>,
3280    last_updated__gt: Option<Vec<String>>,
3281    last_updated__gte: Option<Vec<String>>,
3282    last_updated__isnull: Option<bool>,
3283    last_updated__lt: Option<Vec<String>>,
3284    last_updated__lte: Option<Vec<String>>,
3285    last_updated__n: Option<Vec<String>>,
3286    limit: Option<i32>,
3287    name: Option<Vec<String>>,
3288    name__ic: Option<Vec<String>>,
3289    name__ie: Option<Vec<String>>,
3290    name__iew: Option<Vec<String>>,
3291    name__ire: Option<Vec<String>>,
3292    name__isw: Option<Vec<String>>,
3293    name__n: Option<Vec<String>>,
3294    name__nic: Option<Vec<String>>,
3295    name__nie: Option<Vec<String>>,
3296    name__niew: Option<Vec<String>>,
3297    name__nire: Option<Vec<String>>,
3298    name__nisw: Option<Vec<String>>,
3299    name__nre: Option<Vec<String>>,
3300    name__re: Option<Vec<String>>,
3301    offset: Option<i32>,
3302    q: Option<&str>,
3303    sort: Option<&str>,
3304    teams: Option<Vec<String>>,
3305    teams__isnull: Option<bool>,
3306    teams__n: Option<Vec<String>>,
3307    depth: Option<i32>,
3308    exclude_m2m: Option<bool>,
3309) -> Result<crate::models::PaginatedCircuitTypeList, Error<CircuitsCircuitTypesListError>> {
3310    let local_var_configuration = configuration;
3311
3312    let local_var_client = &local_var_configuration.client;
3313
3314    let local_var_uri_str = format!(
3315        "{}/circuits/circuit-types/",
3316        local_var_configuration.base_path
3317    );
3318    let mut local_var_req_builder =
3319        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3320
3321    if let Some(ref local_var_str) = contacts {
3322        local_var_req_builder = match "multi" {
3323            "multi" => local_var_req_builder.query(
3324                &local_var_str
3325                    .into_iter()
3326                    .map(|p| ("contacts".to_owned(), p.to_string()))
3327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3328            ),
3329            _ => local_var_req_builder.query(&[(
3330                "contacts",
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) = contacts__isnull {
3341        local_var_req_builder =
3342            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
3343    }
3344    if let Some(ref local_var_str) = contacts__n {
3345        local_var_req_builder = match "multi" {
3346            "multi" => local_var_req_builder.query(
3347                &local_var_str
3348                    .into_iter()
3349                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
3350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3351            ),
3352            _ => local_var_req_builder.query(&[(
3353                "contacts__n",
3354                &local_var_str
3355                    .into_iter()
3356                    .map(|p| p.to_string())
3357                    .collect::<Vec<String>>()
3358                    .join(",")
3359                    .to_string(),
3360            )]),
3361        };
3362    }
3363    if let Some(ref local_var_str) = created {
3364        local_var_req_builder = match "multi" {
3365            "multi" => local_var_req_builder.query(
3366                &local_var_str
3367                    .into_iter()
3368                    .map(|p| ("created".to_owned(), p.to_string()))
3369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3370            ),
3371            _ => local_var_req_builder.query(&[(
3372                "created",
3373                &local_var_str
3374                    .into_iter()
3375                    .map(|p| p.to_string())
3376                    .collect::<Vec<String>>()
3377                    .join(",")
3378                    .to_string(),
3379            )]),
3380        };
3381    }
3382    if let Some(ref local_var_str) = created__gt {
3383        local_var_req_builder = match "multi" {
3384            "multi" => local_var_req_builder.query(
3385                &local_var_str
3386                    .into_iter()
3387                    .map(|p| ("created__gt".to_owned(), p.to_string()))
3388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3389            ),
3390            _ => local_var_req_builder.query(&[(
3391                "created__gt",
3392                &local_var_str
3393                    .into_iter()
3394                    .map(|p| p.to_string())
3395                    .collect::<Vec<String>>()
3396                    .join(",")
3397                    .to_string(),
3398            )]),
3399        };
3400    }
3401    if let Some(ref local_var_str) = created__gte {
3402        local_var_req_builder = match "multi" {
3403            "multi" => local_var_req_builder.query(
3404                &local_var_str
3405                    .into_iter()
3406                    .map(|p| ("created__gte".to_owned(), p.to_string()))
3407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3408            ),
3409            _ => local_var_req_builder.query(&[(
3410                "created__gte",
3411                &local_var_str
3412                    .into_iter()
3413                    .map(|p| p.to_string())
3414                    .collect::<Vec<String>>()
3415                    .join(",")
3416                    .to_string(),
3417            )]),
3418        };
3419    }
3420    if let Some(ref local_var_str) = created__isnull {
3421        local_var_req_builder =
3422            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
3423    }
3424    if let Some(ref local_var_str) = created__lt {
3425        local_var_req_builder = match "multi" {
3426            "multi" => local_var_req_builder.query(
3427                &local_var_str
3428                    .into_iter()
3429                    .map(|p| ("created__lt".to_owned(), p.to_string()))
3430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3431            ),
3432            _ => local_var_req_builder.query(&[(
3433                "created__lt",
3434                &local_var_str
3435                    .into_iter()
3436                    .map(|p| p.to_string())
3437                    .collect::<Vec<String>>()
3438                    .join(",")
3439                    .to_string(),
3440            )]),
3441        };
3442    }
3443    if let Some(ref local_var_str) = created__lte {
3444        local_var_req_builder = match "multi" {
3445            "multi" => local_var_req_builder.query(
3446                &local_var_str
3447                    .into_iter()
3448                    .map(|p| ("created__lte".to_owned(), p.to_string()))
3449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3450            ),
3451            _ => local_var_req_builder.query(&[(
3452                "created__lte",
3453                &local_var_str
3454                    .into_iter()
3455                    .map(|p| p.to_string())
3456                    .collect::<Vec<String>>()
3457                    .join(",")
3458                    .to_string(),
3459            )]),
3460        };
3461    }
3462    if let Some(ref local_var_str) = created__n {
3463        local_var_req_builder = match "multi" {
3464            "multi" => local_var_req_builder.query(
3465                &local_var_str
3466                    .into_iter()
3467                    .map(|p| ("created__n".to_owned(), p.to_string()))
3468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3469            ),
3470            _ => local_var_req_builder.query(&[(
3471                "created__n",
3472                &local_var_str
3473                    .into_iter()
3474                    .map(|p| p.to_string())
3475                    .collect::<Vec<String>>()
3476                    .join(",")
3477                    .to_string(),
3478            )]),
3479        };
3480    }
3481    if let Some(ref local_var_str) = description {
3482        local_var_req_builder = match "multi" {
3483            "multi" => local_var_req_builder.query(
3484                &local_var_str
3485                    .into_iter()
3486                    .map(|p| ("description".to_owned(), p.to_string()))
3487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3488            ),
3489            _ => local_var_req_builder.query(&[(
3490                "description",
3491                &local_var_str
3492                    .into_iter()
3493                    .map(|p| p.to_string())
3494                    .collect::<Vec<String>>()
3495                    .join(",")
3496                    .to_string(),
3497            )]),
3498        };
3499    }
3500    if let Some(ref local_var_str) = description__ic {
3501        local_var_req_builder = match "multi" {
3502            "multi" => local_var_req_builder.query(
3503                &local_var_str
3504                    .into_iter()
3505                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3507            ),
3508            _ => local_var_req_builder.query(&[(
3509                "description__ic",
3510                &local_var_str
3511                    .into_iter()
3512                    .map(|p| p.to_string())
3513                    .collect::<Vec<String>>()
3514                    .join(",")
3515                    .to_string(),
3516            )]),
3517        };
3518    }
3519    if let Some(ref local_var_str) = description__ie {
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__ie".to_owned(), p.to_string()))
3525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3526            ),
3527            _ => local_var_req_builder.query(&[(
3528                "description__ie",
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__iew {
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__iew".to_owned(), p.to_string()))
3544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3545            ),
3546            _ => local_var_req_builder.query(&[(
3547                "description__iew",
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__ire {
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__ire".to_owned(), p.to_string()))
3563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3564            ),
3565            _ => local_var_req_builder.query(&[(
3566                "description__ire",
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__isw {
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__isw".to_owned(), p.to_string()))
3582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3583            ),
3584            _ => local_var_req_builder.query(&[(
3585                "description__isw",
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__n {
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__n".to_owned(), p.to_string()))
3601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3602            ),
3603            _ => local_var_req_builder.query(&[(
3604                "description__n",
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__nic {
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__nic".to_owned(), p.to_string()))
3620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3621            ),
3622            _ => local_var_req_builder.query(&[(
3623                "description__nic",
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__nie {
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__nie".to_owned(), p.to_string()))
3639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3640            ),
3641            _ => local_var_req_builder.query(&[(
3642                "description__nie",
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__niew {
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__niew".to_owned(), p.to_string()))
3658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3659            ),
3660            _ => local_var_req_builder.query(&[(
3661                "description__niew",
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__nire {
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__nire".to_owned(), p.to_string()))
3677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3678            ),
3679            _ => local_var_req_builder.query(&[(
3680                "description__nire",
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__nre {
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__nre".to_owned(), p.to_string()))
3715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3716            ),
3717            _ => local_var_req_builder.query(&[(
3718                "description__nre",
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) = description__re {
3729        local_var_req_builder = match "multi" {
3730            "multi" => local_var_req_builder.query(
3731                &local_var_str
3732                    .into_iter()
3733                    .map(|p| ("description__re".to_owned(), p.to_string()))
3734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3735            ),
3736            _ => local_var_req_builder.query(&[(
3737                "description__re",
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) = dynamic_groups {
3748        local_var_req_builder = match "multi" {
3749            "multi" => local_var_req_builder.query(
3750                &local_var_str
3751                    .into_iter()
3752                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
3753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3754            ),
3755            _ => local_var_req_builder.query(&[(
3756                "dynamic_groups",
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) = dynamic_groups__n {
3767        local_var_req_builder = match "multi" {
3768            "multi" => local_var_req_builder.query(
3769                &local_var_str
3770                    .into_iter()
3771                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
3772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3773            ),
3774            _ => local_var_req_builder.query(&[(
3775                "dynamic_groups__n",
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) = format {
3786        local_var_req_builder =
3787            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3788    }
3789    if let Some(ref local_var_str) = id {
3790        local_var_req_builder = match "multi" {
3791            "multi" => local_var_req_builder.query(
3792                &local_var_str
3793                    .into_iter()
3794                    .map(|p| ("id".to_owned(), p.to_string()))
3795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3796            ),
3797            _ => local_var_req_builder.query(&[(
3798                "id",
3799                &local_var_str
3800                    .into_iter()
3801                    .map(|p| p.to_string())
3802                    .collect::<Vec<String>>()
3803                    .join(",")
3804                    .to_string(),
3805            )]),
3806        };
3807    }
3808    if let Some(ref local_var_str) = id__n {
3809        local_var_req_builder = match "multi" {
3810            "multi" => local_var_req_builder.query(
3811                &local_var_str
3812                    .into_iter()
3813                    .map(|p| ("id__n".to_owned(), p.to_string()))
3814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3815            ),
3816            _ => local_var_req_builder.query(&[(
3817                "id__n",
3818                &local_var_str
3819                    .into_iter()
3820                    .map(|p| p.to_string())
3821                    .collect::<Vec<String>>()
3822                    .join(",")
3823                    .to_string(),
3824            )]),
3825        };
3826    }
3827    if let Some(ref local_var_str) = last_updated {
3828        local_var_req_builder = match "multi" {
3829            "multi" => local_var_req_builder.query(
3830                &local_var_str
3831                    .into_iter()
3832                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3834            ),
3835            _ => local_var_req_builder.query(&[(
3836                "last_updated",
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) = last_updated__gt {
3847        local_var_req_builder = match "multi" {
3848            "multi" => local_var_req_builder.query(
3849                &local_var_str
3850                    .into_iter()
3851                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3853            ),
3854            _ => local_var_req_builder.query(&[(
3855                "last_updated__gt",
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) = last_updated__gte {
3866        local_var_req_builder = match "multi" {
3867            "multi" => local_var_req_builder.query(
3868                &local_var_str
3869                    .into_iter()
3870                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3872            ),
3873            _ => local_var_req_builder.query(&[(
3874                "last_updated__gte",
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) = last_updated__isnull {
3885        local_var_req_builder =
3886            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
3887    }
3888    if let Some(ref local_var_str) = last_updated__lt {
3889        local_var_req_builder = match "multi" {
3890            "multi" => local_var_req_builder.query(
3891                &local_var_str
3892                    .into_iter()
3893                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3895            ),
3896            _ => local_var_req_builder.query(&[(
3897                "last_updated__lt",
3898                &local_var_str
3899                    .into_iter()
3900                    .map(|p| p.to_string())
3901                    .collect::<Vec<String>>()
3902                    .join(",")
3903                    .to_string(),
3904            )]),
3905        };
3906    }
3907    if let Some(ref local_var_str) = last_updated__lte {
3908        local_var_req_builder = match "multi" {
3909            "multi" => local_var_req_builder.query(
3910                &local_var_str
3911                    .into_iter()
3912                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3914            ),
3915            _ => local_var_req_builder.query(&[(
3916                "last_updated__lte",
3917                &local_var_str
3918                    .into_iter()
3919                    .map(|p| p.to_string())
3920                    .collect::<Vec<String>>()
3921                    .join(",")
3922                    .to_string(),
3923            )]),
3924        };
3925    }
3926    if let Some(ref local_var_str) = last_updated__n {
3927        local_var_req_builder = match "multi" {
3928            "multi" => local_var_req_builder.query(
3929                &local_var_str
3930                    .into_iter()
3931                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3933            ),
3934            _ => local_var_req_builder.query(&[(
3935                "last_updated__n",
3936                &local_var_str
3937                    .into_iter()
3938                    .map(|p| p.to_string())
3939                    .collect::<Vec<String>>()
3940                    .join(",")
3941                    .to_string(),
3942            )]),
3943        };
3944    }
3945    if let Some(ref local_var_str) = limit {
3946        local_var_req_builder =
3947            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3948    }
3949    if let Some(ref local_var_str) = name {
3950        local_var_req_builder = match "multi" {
3951            "multi" => local_var_req_builder.query(
3952                &local_var_str
3953                    .into_iter()
3954                    .map(|p| ("name".to_owned(), p.to_string()))
3955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3956            ),
3957            _ => local_var_req_builder.query(&[(
3958                "name",
3959                &local_var_str
3960                    .into_iter()
3961                    .map(|p| p.to_string())
3962                    .collect::<Vec<String>>()
3963                    .join(",")
3964                    .to_string(),
3965            )]),
3966        };
3967    }
3968    if let Some(ref local_var_str) = name__ic {
3969        local_var_req_builder = match "multi" {
3970            "multi" => local_var_req_builder.query(
3971                &local_var_str
3972                    .into_iter()
3973                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3975            ),
3976            _ => local_var_req_builder.query(&[(
3977                "name__ic",
3978                &local_var_str
3979                    .into_iter()
3980                    .map(|p| p.to_string())
3981                    .collect::<Vec<String>>()
3982                    .join(",")
3983                    .to_string(),
3984            )]),
3985        };
3986    }
3987    if let Some(ref local_var_str) = name__ie {
3988        local_var_req_builder = match "multi" {
3989            "multi" => local_var_req_builder.query(
3990                &local_var_str
3991                    .into_iter()
3992                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3994            ),
3995            _ => local_var_req_builder.query(&[(
3996                "name__ie",
3997                &local_var_str
3998                    .into_iter()
3999                    .map(|p| p.to_string())
4000                    .collect::<Vec<String>>()
4001                    .join(",")
4002                    .to_string(),
4003            )]),
4004        };
4005    }
4006    if let Some(ref local_var_str) = name__iew {
4007        local_var_req_builder = match "multi" {
4008            "multi" => local_var_req_builder.query(
4009                &local_var_str
4010                    .into_iter()
4011                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4013            ),
4014            _ => local_var_req_builder.query(&[(
4015                "name__iew",
4016                &local_var_str
4017                    .into_iter()
4018                    .map(|p| p.to_string())
4019                    .collect::<Vec<String>>()
4020                    .join(",")
4021                    .to_string(),
4022            )]),
4023        };
4024    }
4025    if let Some(ref local_var_str) = name__ire {
4026        local_var_req_builder = match "multi" {
4027            "multi" => local_var_req_builder.query(
4028                &local_var_str
4029                    .into_iter()
4030                    .map(|p| ("name__ire".to_owned(), p.to_string()))
4031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4032            ),
4033            _ => local_var_req_builder.query(&[(
4034                "name__ire",
4035                &local_var_str
4036                    .into_iter()
4037                    .map(|p| p.to_string())
4038                    .collect::<Vec<String>>()
4039                    .join(",")
4040                    .to_string(),
4041            )]),
4042        };
4043    }
4044    if let Some(ref local_var_str) = name__isw {
4045        local_var_req_builder = match "multi" {
4046            "multi" => local_var_req_builder.query(
4047                &local_var_str
4048                    .into_iter()
4049                    .map(|p| ("name__isw".to_owned(), p.to_string()))
4050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4051            ),
4052            _ => local_var_req_builder.query(&[(
4053                "name__isw",
4054                &local_var_str
4055                    .into_iter()
4056                    .map(|p| p.to_string())
4057                    .collect::<Vec<String>>()
4058                    .join(",")
4059                    .to_string(),
4060            )]),
4061        };
4062    }
4063    if let Some(ref local_var_str) = name__n {
4064        local_var_req_builder = match "multi" {
4065            "multi" => local_var_req_builder.query(
4066                &local_var_str
4067                    .into_iter()
4068                    .map(|p| ("name__n".to_owned(), p.to_string()))
4069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4070            ),
4071            _ => local_var_req_builder.query(&[(
4072                "name__n",
4073                &local_var_str
4074                    .into_iter()
4075                    .map(|p| p.to_string())
4076                    .collect::<Vec<String>>()
4077                    .join(",")
4078                    .to_string(),
4079            )]),
4080        };
4081    }
4082    if let Some(ref local_var_str) = name__nic {
4083        local_var_req_builder = match "multi" {
4084            "multi" => local_var_req_builder.query(
4085                &local_var_str
4086                    .into_iter()
4087                    .map(|p| ("name__nic".to_owned(), p.to_string()))
4088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4089            ),
4090            _ => local_var_req_builder.query(&[(
4091                "name__nic",
4092                &local_var_str
4093                    .into_iter()
4094                    .map(|p| p.to_string())
4095                    .collect::<Vec<String>>()
4096                    .join(",")
4097                    .to_string(),
4098            )]),
4099        };
4100    }
4101    if let Some(ref local_var_str) = name__nie {
4102        local_var_req_builder = match "multi" {
4103            "multi" => local_var_req_builder.query(
4104                &local_var_str
4105                    .into_iter()
4106                    .map(|p| ("name__nie".to_owned(), p.to_string()))
4107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4108            ),
4109            _ => local_var_req_builder.query(&[(
4110                "name__nie",
4111                &local_var_str
4112                    .into_iter()
4113                    .map(|p| p.to_string())
4114                    .collect::<Vec<String>>()
4115                    .join(",")
4116                    .to_string(),
4117            )]),
4118        };
4119    }
4120    if let Some(ref local_var_str) = name__niew {
4121        local_var_req_builder = match "multi" {
4122            "multi" => local_var_req_builder.query(
4123                &local_var_str
4124                    .into_iter()
4125                    .map(|p| ("name__niew".to_owned(), p.to_string()))
4126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4127            ),
4128            _ => local_var_req_builder.query(&[(
4129                "name__niew",
4130                &local_var_str
4131                    .into_iter()
4132                    .map(|p| p.to_string())
4133                    .collect::<Vec<String>>()
4134                    .join(",")
4135                    .to_string(),
4136            )]),
4137        };
4138    }
4139    if let Some(ref local_var_str) = name__nire {
4140        local_var_req_builder = match "multi" {
4141            "multi" => local_var_req_builder.query(
4142                &local_var_str
4143                    .into_iter()
4144                    .map(|p| ("name__nire".to_owned(), p.to_string()))
4145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4146            ),
4147            _ => local_var_req_builder.query(&[(
4148                "name__nire",
4149                &local_var_str
4150                    .into_iter()
4151                    .map(|p| p.to_string())
4152                    .collect::<Vec<String>>()
4153                    .join(",")
4154                    .to_string(),
4155            )]),
4156        };
4157    }
4158    if let Some(ref local_var_str) = name__nisw {
4159        local_var_req_builder = match "multi" {
4160            "multi" => local_var_req_builder.query(
4161                &local_var_str
4162                    .into_iter()
4163                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
4164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4165            ),
4166            _ => local_var_req_builder.query(&[(
4167                "name__nisw",
4168                &local_var_str
4169                    .into_iter()
4170                    .map(|p| p.to_string())
4171                    .collect::<Vec<String>>()
4172                    .join(",")
4173                    .to_string(),
4174            )]),
4175        };
4176    }
4177    if let Some(ref local_var_str) = name__nre {
4178        local_var_req_builder = match "multi" {
4179            "multi" => local_var_req_builder.query(
4180                &local_var_str
4181                    .into_iter()
4182                    .map(|p| ("name__nre".to_owned(), p.to_string()))
4183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4184            ),
4185            _ => local_var_req_builder.query(&[(
4186                "name__nre",
4187                &local_var_str
4188                    .into_iter()
4189                    .map(|p| p.to_string())
4190                    .collect::<Vec<String>>()
4191                    .join(",")
4192                    .to_string(),
4193            )]),
4194        };
4195    }
4196    if let Some(ref local_var_str) = name__re {
4197        local_var_req_builder = match "multi" {
4198            "multi" => local_var_req_builder.query(
4199                &local_var_str
4200                    .into_iter()
4201                    .map(|p| ("name__re".to_owned(), p.to_string()))
4202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4203            ),
4204            _ => local_var_req_builder.query(&[(
4205                "name__re",
4206                &local_var_str
4207                    .into_iter()
4208                    .map(|p| p.to_string())
4209                    .collect::<Vec<String>>()
4210                    .join(",")
4211                    .to_string(),
4212            )]),
4213        };
4214    }
4215    if let Some(ref local_var_str) = offset {
4216        local_var_req_builder =
4217            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4218    }
4219    if let Some(ref local_var_str) = q {
4220        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
4221    }
4222    if let Some(ref local_var_str) = sort {
4223        local_var_req_builder =
4224            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
4225    }
4226    if let Some(ref local_var_str) = teams {
4227        local_var_req_builder = match "multi" {
4228            "multi" => local_var_req_builder.query(
4229                &local_var_str
4230                    .into_iter()
4231                    .map(|p| ("teams".to_owned(), p.to_string()))
4232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4233            ),
4234            _ => local_var_req_builder.query(&[(
4235                "teams",
4236                &local_var_str
4237                    .into_iter()
4238                    .map(|p| p.to_string())
4239                    .collect::<Vec<String>>()
4240                    .join(",")
4241                    .to_string(),
4242            )]),
4243        };
4244    }
4245    if let Some(ref local_var_str) = teams__isnull {
4246        local_var_req_builder =
4247            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
4248    }
4249    if let Some(ref local_var_str) = teams__n {
4250        local_var_req_builder = match "multi" {
4251            "multi" => local_var_req_builder.query(
4252                &local_var_str
4253                    .into_iter()
4254                    .map(|p| ("teams__n".to_owned(), p.to_string()))
4255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4256            ),
4257            _ => local_var_req_builder.query(&[(
4258                "teams__n",
4259                &local_var_str
4260                    .into_iter()
4261                    .map(|p| p.to_string())
4262                    .collect::<Vec<String>>()
4263                    .join(",")
4264                    .to_string(),
4265            )]),
4266        };
4267    }
4268    if let Some(ref local_var_str) = depth {
4269        local_var_req_builder =
4270            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4271    }
4272    if let Some(ref local_var_str) = exclude_m2m {
4273        local_var_req_builder =
4274            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4275    }
4276    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4277        local_var_req_builder =
4278            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4279    }
4280    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4281        let local_var_key = local_var_apikey.key.clone();
4282        let local_var_value = match local_var_apikey.prefix {
4283            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4284            None => local_var_key,
4285        };
4286        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4287    };
4288
4289    let local_var_req = local_var_req_builder.build()?;
4290    let local_var_resp = local_var_client.execute(local_var_req).await?;
4291
4292    let local_var_status = local_var_resp.status();
4293    let local_var_content = local_var_resp.text().await?;
4294
4295    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4296        serde_json::from_str(&local_var_content).map_err(Error::from)
4297    } else {
4298        let local_var_entity: Option<CircuitsCircuitTypesListError> =
4299            serde_json::from_str(&local_var_content).ok();
4300        let local_var_error = ResponseContent {
4301            status: local_var_status,
4302            content: local_var_content,
4303            entity: local_var_entity,
4304        };
4305        Err(Error::ResponseError(local_var_error))
4306    }
4307}
4308
4309/// API methods for returning or creating notes on an object.
4310pub async fn circuits_circuit_types_notes_create(
4311    configuration: &configuration::Configuration,
4312    id: &str,
4313    note_input_request: crate::models::NoteInputRequest,
4314    format: Option<&str>,
4315) -> Result<crate::models::Note, Error<CircuitsCircuitTypesNotesCreateError>> {
4316    let local_var_configuration = configuration;
4317
4318    let local_var_client = &local_var_configuration.client;
4319
4320    let local_var_uri_str = format!(
4321        "{}/circuits/circuit-types/{id}/notes/",
4322        local_var_configuration.base_path,
4323        id = crate::apis::urlencode(id)
4324    );
4325    let mut local_var_req_builder =
4326        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4327
4328    if let Some(ref local_var_str) = format {
4329        local_var_req_builder =
4330            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4331    }
4332    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4333        local_var_req_builder =
4334            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4335    }
4336    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4337        let local_var_key = local_var_apikey.key.clone();
4338        let local_var_value = match local_var_apikey.prefix {
4339            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4340            None => local_var_key,
4341        };
4342        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4343    };
4344    local_var_req_builder = local_var_req_builder.json(&note_input_request);
4345
4346    let local_var_req = local_var_req_builder.build()?;
4347    let local_var_resp = local_var_client.execute(local_var_req).await?;
4348
4349    let local_var_status = local_var_resp.status();
4350    let local_var_content = local_var_resp.text().await?;
4351
4352    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4353        serde_json::from_str(&local_var_content).map_err(Error::from)
4354    } else {
4355        let local_var_entity: Option<CircuitsCircuitTypesNotesCreateError> =
4356            serde_json::from_str(&local_var_content).ok();
4357        let local_var_error = ResponseContent {
4358            status: local_var_status,
4359            content: local_var_content,
4360            entity: local_var_entity,
4361        };
4362        Err(Error::ResponseError(local_var_error))
4363    }
4364}
4365
4366/// API methods for returning or creating notes on an object.
4367pub async fn circuits_circuit_types_notes_list(
4368    configuration: &configuration::Configuration,
4369    id: &str,
4370    format: Option<&str>,
4371    limit: Option<i32>,
4372    offset: Option<i32>,
4373    depth: Option<i32>,
4374    exclude_m2m: Option<bool>,
4375) -> Result<crate::models::PaginatedNoteList, Error<CircuitsCircuitTypesNotesListError>> {
4376    let local_var_configuration = configuration;
4377
4378    let local_var_client = &local_var_configuration.client;
4379
4380    let local_var_uri_str = format!(
4381        "{}/circuits/circuit-types/{id}/notes/",
4382        local_var_configuration.base_path,
4383        id = crate::apis::urlencode(id)
4384    );
4385    let mut local_var_req_builder =
4386        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4387
4388    if let Some(ref local_var_str) = format {
4389        local_var_req_builder =
4390            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4391    }
4392    if let Some(ref local_var_str) = limit {
4393        local_var_req_builder =
4394            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4395    }
4396    if let Some(ref local_var_str) = offset {
4397        local_var_req_builder =
4398            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4399    }
4400    if let Some(ref local_var_str) = depth {
4401        local_var_req_builder =
4402            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4403    }
4404    if let Some(ref local_var_str) = exclude_m2m {
4405        local_var_req_builder =
4406            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4407    }
4408    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4409        local_var_req_builder =
4410            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4411    }
4412    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4413        let local_var_key = local_var_apikey.key.clone();
4414        let local_var_value = match local_var_apikey.prefix {
4415            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4416            None => local_var_key,
4417        };
4418        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4419    };
4420
4421    let local_var_req = local_var_req_builder.build()?;
4422    let local_var_resp = local_var_client.execute(local_var_req).await?;
4423
4424    let local_var_status = local_var_resp.status();
4425    let local_var_content = local_var_resp.text().await?;
4426
4427    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4428        serde_json::from_str(&local_var_content).map_err(Error::from)
4429    } else {
4430        let local_var_entity: Option<CircuitsCircuitTypesNotesListError> =
4431            serde_json::from_str(&local_var_content).ok();
4432        let local_var_error = ResponseContent {
4433            status: local_var_status,
4434            content: local_var_content,
4435            entity: local_var_entity,
4436        };
4437        Err(Error::ResponseError(local_var_error))
4438    }
4439}
4440
4441/// Partial update a circuit type object.
4442pub async fn circuits_circuit_types_partial_update(
4443    configuration: &configuration::Configuration,
4444    id: &str,
4445    format: Option<&str>,
4446    patched_circuit_type_request: Option<crate::models::PatchedCircuitTypeRequest>,
4447) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesPartialUpdateError>> {
4448    let local_var_configuration = configuration;
4449
4450    let local_var_client = &local_var_configuration.client;
4451
4452    let local_var_uri_str = format!(
4453        "{}/circuits/circuit-types/{id}/",
4454        local_var_configuration.base_path,
4455        id = crate::apis::urlencode(id)
4456    );
4457    let mut local_var_req_builder =
4458        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4459
4460    if let Some(ref local_var_str) = format {
4461        local_var_req_builder =
4462            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4463    }
4464    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4465        local_var_req_builder =
4466            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4467    }
4468    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4469        let local_var_key = local_var_apikey.key.clone();
4470        let local_var_value = match local_var_apikey.prefix {
4471            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4472            None => local_var_key,
4473        };
4474        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4475    };
4476    local_var_req_builder = local_var_req_builder.json(&patched_circuit_type_request);
4477
4478    let local_var_req = local_var_req_builder.build()?;
4479    let local_var_resp = local_var_client.execute(local_var_req).await?;
4480
4481    let local_var_status = local_var_resp.status();
4482    let local_var_content = local_var_resp.text().await?;
4483
4484    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4485        serde_json::from_str(&local_var_content).map_err(Error::from)
4486    } else {
4487        let local_var_entity: Option<CircuitsCircuitTypesPartialUpdateError> =
4488            serde_json::from_str(&local_var_content).ok();
4489        let local_var_error = ResponseContent {
4490            status: local_var_status,
4491            content: local_var_content,
4492            entity: local_var_entity,
4493        };
4494        Err(Error::ResponseError(local_var_error))
4495    }
4496}
4497
4498/// Retrieve a circuit type object.
4499pub async fn circuits_circuit_types_retrieve(
4500    configuration: &configuration::Configuration,
4501    id: &str,
4502    format: Option<&str>,
4503    depth: Option<i32>,
4504    exclude_m2m: Option<bool>,
4505) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesRetrieveError>> {
4506    let local_var_configuration = configuration;
4507
4508    let local_var_client = &local_var_configuration.client;
4509
4510    let local_var_uri_str = format!(
4511        "{}/circuits/circuit-types/{id}/",
4512        local_var_configuration.base_path,
4513        id = crate::apis::urlencode(id)
4514    );
4515    let mut local_var_req_builder =
4516        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4517
4518    if let Some(ref local_var_str) = format {
4519        local_var_req_builder =
4520            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4521    }
4522    if let Some(ref local_var_str) = depth {
4523        local_var_req_builder =
4524            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
4525    }
4526    if let Some(ref local_var_str) = exclude_m2m {
4527        local_var_req_builder =
4528            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
4529    }
4530    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4531        local_var_req_builder =
4532            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4533    }
4534    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4535        let local_var_key = local_var_apikey.key.clone();
4536        let local_var_value = match local_var_apikey.prefix {
4537            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4538            None => local_var_key,
4539        };
4540        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4541    };
4542
4543    let local_var_req = local_var_req_builder.build()?;
4544    let local_var_resp = local_var_client.execute(local_var_req).await?;
4545
4546    let local_var_status = local_var_resp.status();
4547    let local_var_content = local_var_resp.text().await?;
4548
4549    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4550        serde_json::from_str(&local_var_content).map_err(Error::from)
4551    } else {
4552        let local_var_entity: Option<CircuitsCircuitTypesRetrieveError> =
4553            serde_json::from_str(&local_var_content).ok();
4554        let local_var_error = ResponseContent {
4555            status: local_var_status,
4556            content: local_var_content,
4557            entity: local_var_entity,
4558        };
4559        Err(Error::ResponseError(local_var_error))
4560    }
4561}
4562
4563/// Update a circuit type object.
4564pub async fn circuits_circuit_types_update(
4565    configuration: &configuration::Configuration,
4566    id: &str,
4567    circuit_type_request: crate::models::CircuitTypeRequest,
4568    format: Option<&str>,
4569) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesUpdateError>> {
4570    let local_var_configuration = configuration;
4571
4572    let local_var_client = &local_var_configuration.client;
4573
4574    let local_var_uri_str = format!(
4575        "{}/circuits/circuit-types/{id}/",
4576        local_var_configuration.base_path,
4577        id = crate::apis::urlencode(id)
4578    );
4579    let mut local_var_req_builder =
4580        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4581
4582    if let Some(ref local_var_str) = format {
4583        local_var_req_builder =
4584            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4585    }
4586    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4587        local_var_req_builder =
4588            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4589    }
4590    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4591        let local_var_key = local_var_apikey.key.clone();
4592        let local_var_value = match local_var_apikey.prefix {
4593            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4594            None => local_var_key,
4595        };
4596        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4597    };
4598    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
4599
4600    let local_var_req = local_var_req_builder.build()?;
4601    let local_var_resp = local_var_client.execute(local_var_req).await?;
4602
4603    let local_var_status = local_var_resp.status();
4604    let local_var_content = local_var_resp.text().await?;
4605
4606    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4607        serde_json::from_str(&local_var_content).map_err(Error::from)
4608    } else {
4609        let local_var_entity: Option<CircuitsCircuitTypesUpdateError> =
4610            serde_json::from_str(&local_var_content).ok();
4611        let local_var_error = ResponseContent {
4612            status: local_var_status,
4613            content: local_var_content,
4614            entity: local_var_entity,
4615        };
4616        Err(Error::ResponseError(local_var_error))
4617    }
4618}
4619
4620/// Destroy a list of circuit objects.
4621pub async fn circuits_circuits_bulk_destroy(
4622    configuration: &configuration::Configuration,
4623    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
4624    format: Option<&str>,
4625) -> Result<(), Error<CircuitsCircuitsBulkDestroyError>> {
4626    let local_var_configuration = configuration;
4627
4628    let local_var_client = &local_var_configuration.client;
4629
4630    let local_var_uri_str = format!("{}/circuits/circuits/", local_var_configuration.base_path);
4631    let mut local_var_req_builder =
4632        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4633
4634    if let Some(ref local_var_str) = format {
4635        local_var_req_builder =
4636            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4637    }
4638    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4639        local_var_req_builder =
4640            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4641    }
4642    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4643        let local_var_key = local_var_apikey.key.clone();
4644        let local_var_value = match local_var_apikey.prefix {
4645            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4646            None => local_var_key,
4647        };
4648        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4649    };
4650    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
4651
4652    let local_var_req = local_var_req_builder.build()?;
4653    let local_var_resp = local_var_client.execute(local_var_req).await?;
4654
4655    let local_var_status = local_var_resp.status();
4656    let local_var_content = local_var_resp.text().await?;
4657
4658    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4659        Ok(())
4660    } else {
4661        let local_var_entity: Option<CircuitsCircuitsBulkDestroyError> =
4662            serde_json::from_str(&local_var_content).ok();
4663        let local_var_error = ResponseContent {
4664            status: local_var_status,
4665            content: local_var_content,
4666            entity: local_var_entity,
4667        };
4668        Err(Error::ResponseError(local_var_error))
4669    }
4670}
4671
4672/// Partial update a list of circuit objects.
4673pub async fn circuits_circuits_bulk_partial_update(
4674    configuration: &configuration::Configuration,
4675    patched_bulk_writable_circuit_request: Vec<crate::models::PatchedBulkWritableCircuitRequest>,
4676    format: Option<&str>,
4677) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkPartialUpdateError>> {
4678    let local_var_configuration = configuration;
4679
4680    let local_var_client = &local_var_configuration.client;
4681
4682    let local_var_uri_str = format!("{}/circuits/circuits/", local_var_configuration.base_path);
4683    let mut local_var_req_builder =
4684        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4685
4686    if let Some(ref local_var_str) = format {
4687        local_var_req_builder =
4688            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4689    }
4690    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4691        local_var_req_builder =
4692            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4693    }
4694    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4695        let local_var_key = local_var_apikey.key.clone();
4696        let local_var_value = match local_var_apikey.prefix {
4697            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4698            None => local_var_key,
4699        };
4700        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4701    };
4702    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_circuit_request);
4703
4704    let local_var_req = local_var_req_builder.build()?;
4705    let local_var_resp = local_var_client.execute(local_var_req).await?;
4706
4707    let local_var_status = local_var_resp.status();
4708    let local_var_content = local_var_resp.text().await?;
4709
4710    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4711        serde_json::from_str(&local_var_content).map_err(Error::from)
4712    } else {
4713        let local_var_entity: Option<CircuitsCircuitsBulkPartialUpdateError> =
4714            serde_json::from_str(&local_var_content).ok();
4715        let local_var_error = ResponseContent {
4716            status: local_var_status,
4717            content: local_var_content,
4718            entity: local_var_entity,
4719        };
4720        Err(Error::ResponseError(local_var_error))
4721    }
4722}
4723
4724/// Update a list of circuit objects.
4725pub async fn circuits_circuits_bulk_update(
4726    configuration: &configuration::Configuration,
4727    bulk_writable_circuit_request: Vec<crate::models::BulkWritableCircuitRequest>,
4728    format: Option<&str>,
4729) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkUpdateError>> {
4730    let local_var_configuration = configuration;
4731
4732    let local_var_client = &local_var_configuration.client;
4733
4734    let local_var_uri_str = format!("{}/circuits/circuits/", local_var_configuration.base_path);
4735    let mut local_var_req_builder =
4736        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4737
4738    if let Some(ref local_var_str) = format {
4739        local_var_req_builder =
4740            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4741    }
4742    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4743        local_var_req_builder =
4744            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4745    }
4746    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4747        let local_var_key = local_var_apikey.key.clone();
4748        let local_var_value = match local_var_apikey.prefix {
4749            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4750            None => local_var_key,
4751        };
4752        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4753    };
4754    local_var_req_builder = local_var_req_builder.json(&bulk_writable_circuit_request);
4755
4756    let local_var_req = local_var_req_builder.build()?;
4757    let local_var_resp = local_var_client.execute(local_var_req).await?;
4758
4759    let local_var_status = local_var_resp.status();
4760    let local_var_content = local_var_resp.text().await?;
4761
4762    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4763        serde_json::from_str(&local_var_content).map_err(Error::from)
4764    } else {
4765        let local_var_entity: Option<CircuitsCircuitsBulkUpdateError> =
4766            serde_json::from_str(&local_var_content).ok();
4767        let local_var_error = ResponseContent {
4768            status: local_var_status,
4769            content: local_var_content,
4770            entity: local_var_entity,
4771        };
4772        Err(Error::ResponseError(local_var_error))
4773    }
4774}
4775
4776/// Create one or more circuit objects.
4777pub async fn circuits_circuits_create(
4778    configuration: &configuration::Configuration,
4779    circuit_request: crate::models::CircuitRequest,
4780    format: Option<&str>,
4781) -> Result<crate::models::Circuit, Error<CircuitsCircuitsCreateError>> {
4782    let local_var_configuration = configuration;
4783
4784    let local_var_client = &local_var_configuration.client;
4785
4786    let local_var_uri_str = format!("{}/circuits/circuits/", local_var_configuration.base_path);
4787    let mut local_var_req_builder =
4788        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4789
4790    if let Some(ref local_var_str) = format {
4791        local_var_req_builder =
4792            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4793    }
4794    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4795        local_var_req_builder =
4796            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4797    }
4798    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4799        let local_var_key = local_var_apikey.key.clone();
4800        let local_var_value = match local_var_apikey.prefix {
4801            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4802            None => local_var_key,
4803        };
4804        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4805    };
4806    local_var_req_builder = local_var_req_builder.json(&circuit_request);
4807
4808    let local_var_req = local_var_req_builder.build()?;
4809    let local_var_resp = local_var_client.execute(local_var_req).await?;
4810
4811    let local_var_status = local_var_resp.status();
4812    let local_var_content = local_var_resp.text().await?;
4813
4814    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4815        serde_json::from_str(&local_var_content).map_err(Error::from)
4816    } else {
4817        let local_var_entity: Option<CircuitsCircuitsCreateError> =
4818            serde_json::from_str(&local_var_content).ok();
4819        let local_var_error = ResponseContent {
4820            status: local_var_status,
4821            content: local_var_content,
4822            entity: local_var_entity,
4823        };
4824        Err(Error::ResponseError(local_var_error))
4825    }
4826}
4827
4828/// Destroy a circuit object.
4829pub async fn circuits_circuits_destroy(
4830    configuration: &configuration::Configuration,
4831    id: &str,
4832    format: Option<&str>,
4833) -> Result<(), Error<CircuitsCircuitsDestroyError>> {
4834    let local_var_configuration = configuration;
4835
4836    let local_var_client = &local_var_configuration.client;
4837
4838    let local_var_uri_str = format!(
4839        "{}/circuits/circuits/{id}/",
4840        local_var_configuration.base_path,
4841        id = crate::apis::urlencode(id)
4842    );
4843    let mut local_var_req_builder =
4844        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4845
4846    if let Some(ref local_var_str) = format {
4847        local_var_req_builder =
4848            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4849    }
4850    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4851        local_var_req_builder =
4852            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4853    }
4854    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4855        let local_var_key = local_var_apikey.key.clone();
4856        let local_var_value = match local_var_apikey.prefix {
4857            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4858            None => local_var_key,
4859        };
4860        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4861    };
4862
4863    let local_var_req = local_var_req_builder.build()?;
4864    let local_var_resp = local_var_client.execute(local_var_req).await?;
4865
4866    let local_var_status = local_var_resp.status();
4867    let local_var_content = local_var_resp.text().await?;
4868
4869    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4870        Ok(())
4871    } else {
4872        let local_var_entity: Option<CircuitsCircuitsDestroyError> =
4873            serde_json::from_str(&local_var_content).ok();
4874        let local_var_error = ResponseContent {
4875            status: local_var_status,
4876            content: local_var_content,
4877            entity: local_var_entity,
4878        };
4879        Err(Error::ResponseError(local_var_error))
4880    }
4881}
4882
4883/// Retrieve a list of circuit objects.
4884pub async fn circuits_circuits_list(
4885    configuration: &configuration::Configuration,
4886    cid: Option<Vec<String>>,
4887    cid__ic: Option<Vec<String>>,
4888    cid__ie: Option<Vec<String>>,
4889    cid__iew: Option<Vec<String>>,
4890    cid__ire: Option<Vec<String>>,
4891    cid__isw: Option<Vec<String>>,
4892    cid__n: Option<Vec<String>>,
4893    cid__nic: Option<Vec<String>>,
4894    cid__nie: Option<Vec<String>>,
4895    cid__niew: Option<Vec<String>>,
4896    cid__nire: Option<Vec<String>>,
4897    cid__nisw: Option<Vec<String>>,
4898    cid__nre: Option<Vec<String>>,
4899    cid__re: Option<Vec<String>>,
4900    circuit_termination_a: Option<Vec<uuid::Uuid>>,
4901    circuit_termination_a__isnull: Option<bool>,
4902    circuit_termination_a__n: Option<Vec<uuid::Uuid>>,
4903    circuit_termination_z: Option<Vec<uuid::Uuid>>,
4904    circuit_termination_z__isnull: Option<bool>,
4905    circuit_termination_z__n: Option<Vec<uuid::Uuid>>,
4906    circuit_terminations: Option<Vec<uuid::Uuid>>,
4907    circuit_terminations__isnull: Option<bool>,
4908    circuit_terminations__n: Option<Vec<uuid::Uuid>>,
4909    circuit_type: Option<Vec<String>>,
4910    circuit_type__n: Option<Vec<String>>,
4911    cloud_network: Option<Vec<String>>,
4912    cloud_network__isnull: Option<bool>,
4913    cloud_network__n: Option<Vec<String>>,
4914    comments: Option<Vec<String>>,
4915    comments__ic: Option<Vec<String>>,
4916    comments__ie: Option<Vec<String>>,
4917    comments__iew: Option<Vec<String>>,
4918    comments__ire: Option<Vec<String>>,
4919    comments__isw: Option<Vec<String>>,
4920    comments__n: Option<Vec<String>>,
4921    comments__nic: Option<Vec<String>>,
4922    comments__nie: Option<Vec<String>>,
4923    comments__niew: Option<Vec<String>>,
4924    comments__nire: Option<Vec<String>>,
4925    comments__nisw: Option<Vec<String>>,
4926    comments__nre: Option<Vec<String>>,
4927    comments__re: Option<Vec<String>>,
4928    commit_rate: Option<Vec<i32>>,
4929    commit_rate__gt: Option<Vec<i32>>,
4930    commit_rate__gte: Option<Vec<i32>>,
4931    commit_rate__isnull: Option<bool>,
4932    commit_rate__lt: Option<Vec<i32>>,
4933    commit_rate__lte: Option<Vec<i32>>,
4934    commit_rate__n: Option<Vec<i32>>,
4935    contacts: Option<Vec<String>>,
4936    contacts__isnull: Option<bool>,
4937    contacts__n: Option<Vec<String>>,
4938    created: Option<Vec<String>>,
4939    created__gt: Option<Vec<String>>,
4940    created__gte: Option<Vec<String>>,
4941    created__isnull: Option<bool>,
4942    created__lt: Option<Vec<String>>,
4943    created__lte: Option<Vec<String>>,
4944    created__n: Option<Vec<String>>,
4945    description: Option<Vec<String>>,
4946    description__ic: Option<Vec<String>>,
4947    description__ie: Option<Vec<String>>,
4948    description__iew: Option<Vec<String>>,
4949    description__ire: Option<Vec<String>>,
4950    description__isw: Option<Vec<String>>,
4951    description__n: Option<Vec<String>>,
4952    description__nic: Option<Vec<String>>,
4953    description__nie: Option<Vec<String>>,
4954    description__niew: Option<Vec<String>>,
4955    description__nire: Option<Vec<String>>,
4956    description__nisw: Option<Vec<String>>,
4957    description__nre: Option<Vec<String>>,
4958    description__re: Option<Vec<String>>,
4959    dynamic_groups: Option<Vec<String>>,
4960    dynamic_groups__n: Option<Vec<String>>,
4961    format: Option<&str>,
4962    has_terminations: Option<bool>,
4963    id: Option<Vec<uuid::Uuid>>,
4964    id__n: Option<Vec<uuid::Uuid>>,
4965    install_date: Option<Vec<String>>,
4966    install_date__gt: Option<Vec<String>>,
4967    install_date__gte: Option<Vec<String>>,
4968    install_date__isnull: Option<bool>,
4969    install_date__lt: Option<Vec<String>>,
4970    install_date__lte: Option<Vec<String>>,
4971    install_date__n: Option<Vec<String>>,
4972    last_updated: Option<Vec<String>>,
4973    last_updated__gt: Option<Vec<String>>,
4974    last_updated__gte: Option<Vec<String>>,
4975    last_updated__isnull: Option<bool>,
4976    last_updated__lt: Option<Vec<String>>,
4977    last_updated__lte: Option<Vec<String>>,
4978    last_updated__n: Option<Vec<String>>,
4979    limit: Option<i32>,
4980    location: Option<Vec<String>>,
4981    location__isnull: Option<bool>,
4982    location__n: Option<Vec<String>>,
4983    offset: Option<i32>,
4984    provider: Option<Vec<String>>,
4985    provider__n: Option<Vec<String>>,
4986    provider_network: Option<Vec<String>>,
4987    provider_network__isnull: Option<bool>,
4988    provider_network__n: Option<Vec<String>>,
4989    q: Option<&str>,
4990    sort: Option<&str>,
4991    status: Option<Vec<String>>,
4992    status__n: Option<Vec<String>>,
4993    tags: Option<Vec<String>>,
4994    tags__isnull: Option<bool>,
4995    tags__n: Option<Vec<String>>,
4996    teams: Option<Vec<String>>,
4997    teams__isnull: Option<bool>,
4998    teams__n: Option<Vec<String>>,
4999    tenant: Option<Vec<String>>,
5000    tenant__isnull: Option<bool>,
5001    tenant__n: Option<Vec<String>>,
5002    tenant_group: Option<Vec<String>>,
5003    tenant_group__isnull: Option<bool>,
5004    tenant_group__n: Option<Vec<String>>,
5005    tenant_id: Option<Vec<uuid::Uuid>>,
5006    tenant_id__isnull: Option<bool>,
5007    tenant_id__n: Option<Vec<uuid::Uuid>>,
5008    depth: Option<i32>,
5009    exclude_m2m: Option<bool>,
5010) -> Result<crate::models::PaginatedCircuitList, Error<CircuitsCircuitsListError>> {
5011    let local_var_configuration = configuration;
5012
5013    let local_var_client = &local_var_configuration.client;
5014
5015    let local_var_uri_str = format!("{}/circuits/circuits/", local_var_configuration.base_path);
5016    let mut local_var_req_builder =
5017        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5018
5019    if let Some(ref local_var_str) = cid {
5020        local_var_req_builder = match "multi" {
5021            "multi" => local_var_req_builder.query(
5022                &local_var_str
5023                    .into_iter()
5024                    .map(|p| ("cid".to_owned(), p.to_string()))
5025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5026            ),
5027            _ => local_var_req_builder.query(&[(
5028                "cid",
5029                &local_var_str
5030                    .into_iter()
5031                    .map(|p| p.to_string())
5032                    .collect::<Vec<String>>()
5033                    .join(",")
5034                    .to_string(),
5035            )]),
5036        };
5037    }
5038    if let Some(ref local_var_str) = cid__ic {
5039        local_var_req_builder = match "multi" {
5040            "multi" => local_var_req_builder.query(
5041                &local_var_str
5042                    .into_iter()
5043                    .map(|p| ("cid__ic".to_owned(), p.to_string()))
5044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5045            ),
5046            _ => local_var_req_builder.query(&[(
5047                "cid__ic",
5048                &local_var_str
5049                    .into_iter()
5050                    .map(|p| p.to_string())
5051                    .collect::<Vec<String>>()
5052                    .join(",")
5053                    .to_string(),
5054            )]),
5055        };
5056    }
5057    if let Some(ref local_var_str) = cid__ie {
5058        local_var_req_builder = match "multi" {
5059            "multi" => local_var_req_builder.query(
5060                &local_var_str
5061                    .into_iter()
5062                    .map(|p| ("cid__ie".to_owned(), p.to_string()))
5063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5064            ),
5065            _ => local_var_req_builder.query(&[(
5066                "cid__ie",
5067                &local_var_str
5068                    .into_iter()
5069                    .map(|p| p.to_string())
5070                    .collect::<Vec<String>>()
5071                    .join(",")
5072                    .to_string(),
5073            )]),
5074        };
5075    }
5076    if let Some(ref local_var_str) = cid__iew {
5077        local_var_req_builder = match "multi" {
5078            "multi" => local_var_req_builder.query(
5079                &local_var_str
5080                    .into_iter()
5081                    .map(|p| ("cid__iew".to_owned(), p.to_string()))
5082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5083            ),
5084            _ => local_var_req_builder.query(&[(
5085                "cid__iew",
5086                &local_var_str
5087                    .into_iter()
5088                    .map(|p| p.to_string())
5089                    .collect::<Vec<String>>()
5090                    .join(",")
5091                    .to_string(),
5092            )]),
5093        };
5094    }
5095    if let Some(ref local_var_str) = cid__ire {
5096        local_var_req_builder = match "multi" {
5097            "multi" => local_var_req_builder.query(
5098                &local_var_str
5099                    .into_iter()
5100                    .map(|p| ("cid__ire".to_owned(), p.to_string()))
5101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5102            ),
5103            _ => local_var_req_builder.query(&[(
5104                "cid__ire",
5105                &local_var_str
5106                    .into_iter()
5107                    .map(|p| p.to_string())
5108                    .collect::<Vec<String>>()
5109                    .join(",")
5110                    .to_string(),
5111            )]),
5112        };
5113    }
5114    if let Some(ref local_var_str) = cid__isw {
5115        local_var_req_builder = match "multi" {
5116            "multi" => local_var_req_builder.query(
5117                &local_var_str
5118                    .into_iter()
5119                    .map(|p| ("cid__isw".to_owned(), p.to_string()))
5120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5121            ),
5122            _ => local_var_req_builder.query(&[(
5123                "cid__isw",
5124                &local_var_str
5125                    .into_iter()
5126                    .map(|p| p.to_string())
5127                    .collect::<Vec<String>>()
5128                    .join(",")
5129                    .to_string(),
5130            )]),
5131        };
5132    }
5133    if let Some(ref local_var_str) = cid__n {
5134        local_var_req_builder = match "multi" {
5135            "multi" => local_var_req_builder.query(
5136                &local_var_str
5137                    .into_iter()
5138                    .map(|p| ("cid__n".to_owned(), p.to_string()))
5139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5140            ),
5141            _ => local_var_req_builder.query(&[(
5142                "cid__n",
5143                &local_var_str
5144                    .into_iter()
5145                    .map(|p| p.to_string())
5146                    .collect::<Vec<String>>()
5147                    .join(",")
5148                    .to_string(),
5149            )]),
5150        };
5151    }
5152    if let Some(ref local_var_str) = cid__nic {
5153        local_var_req_builder = match "multi" {
5154            "multi" => local_var_req_builder.query(
5155                &local_var_str
5156                    .into_iter()
5157                    .map(|p| ("cid__nic".to_owned(), p.to_string()))
5158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5159            ),
5160            _ => local_var_req_builder.query(&[(
5161                "cid__nic",
5162                &local_var_str
5163                    .into_iter()
5164                    .map(|p| p.to_string())
5165                    .collect::<Vec<String>>()
5166                    .join(",")
5167                    .to_string(),
5168            )]),
5169        };
5170    }
5171    if let Some(ref local_var_str) = cid__nie {
5172        local_var_req_builder = match "multi" {
5173            "multi" => local_var_req_builder.query(
5174                &local_var_str
5175                    .into_iter()
5176                    .map(|p| ("cid__nie".to_owned(), p.to_string()))
5177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5178            ),
5179            _ => local_var_req_builder.query(&[(
5180                "cid__nie",
5181                &local_var_str
5182                    .into_iter()
5183                    .map(|p| p.to_string())
5184                    .collect::<Vec<String>>()
5185                    .join(",")
5186                    .to_string(),
5187            )]),
5188        };
5189    }
5190    if let Some(ref local_var_str) = cid__niew {
5191        local_var_req_builder = match "multi" {
5192            "multi" => local_var_req_builder.query(
5193                &local_var_str
5194                    .into_iter()
5195                    .map(|p| ("cid__niew".to_owned(), p.to_string()))
5196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5197            ),
5198            _ => local_var_req_builder.query(&[(
5199                "cid__niew",
5200                &local_var_str
5201                    .into_iter()
5202                    .map(|p| p.to_string())
5203                    .collect::<Vec<String>>()
5204                    .join(",")
5205                    .to_string(),
5206            )]),
5207        };
5208    }
5209    if let Some(ref local_var_str) = cid__nire {
5210        local_var_req_builder = match "multi" {
5211            "multi" => local_var_req_builder.query(
5212                &local_var_str
5213                    .into_iter()
5214                    .map(|p| ("cid__nire".to_owned(), p.to_string()))
5215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5216            ),
5217            _ => local_var_req_builder.query(&[(
5218                "cid__nire",
5219                &local_var_str
5220                    .into_iter()
5221                    .map(|p| p.to_string())
5222                    .collect::<Vec<String>>()
5223                    .join(",")
5224                    .to_string(),
5225            )]),
5226        };
5227    }
5228    if let Some(ref local_var_str) = cid__nisw {
5229        local_var_req_builder = match "multi" {
5230            "multi" => local_var_req_builder.query(
5231                &local_var_str
5232                    .into_iter()
5233                    .map(|p| ("cid__nisw".to_owned(), p.to_string()))
5234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5235            ),
5236            _ => local_var_req_builder.query(&[(
5237                "cid__nisw",
5238                &local_var_str
5239                    .into_iter()
5240                    .map(|p| p.to_string())
5241                    .collect::<Vec<String>>()
5242                    .join(",")
5243                    .to_string(),
5244            )]),
5245        };
5246    }
5247    if let Some(ref local_var_str) = cid__nre {
5248        local_var_req_builder = match "multi" {
5249            "multi" => local_var_req_builder.query(
5250                &local_var_str
5251                    .into_iter()
5252                    .map(|p| ("cid__nre".to_owned(), p.to_string()))
5253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5254            ),
5255            _ => local_var_req_builder.query(&[(
5256                "cid__nre",
5257                &local_var_str
5258                    .into_iter()
5259                    .map(|p| p.to_string())
5260                    .collect::<Vec<String>>()
5261                    .join(",")
5262                    .to_string(),
5263            )]),
5264        };
5265    }
5266    if let Some(ref local_var_str) = cid__re {
5267        local_var_req_builder = match "multi" {
5268            "multi" => local_var_req_builder.query(
5269                &local_var_str
5270                    .into_iter()
5271                    .map(|p| ("cid__re".to_owned(), p.to_string()))
5272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5273            ),
5274            _ => local_var_req_builder.query(&[(
5275                "cid__re",
5276                &local_var_str
5277                    .into_iter()
5278                    .map(|p| p.to_string())
5279                    .collect::<Vec<String>>()
5280                    .join(",")
5281                    .to_string(),
5282            )]),
5283        };
5284    }
5285    if let Some(ref local_var_str) = circuit_termination_a {
5286        local_var_req_builder = match "multi" {
5287            "multi" => local_var_req_builder.query(
5288                &local_var_str
5289                    .into_iter()
5290                    .map(|p| ("circuit_termination_a".to_owned(), p.to_string()))
5291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5292            ),
5293            _ => local_var_req_builder.query(&[(
5294                "circuit_termination_a",
5295                &local_var_str
5296                    .into_iter()
5297                    .map(|p| p.to_string())
5298                    .collect::<Vec<String>>()
5299                    .join(",")
5300                    .to_string(),
5301            )]),
5302        };
5303    }
5304    if let Some(ref local_var_str) = circuit_termination_a__isnull {
5305        local_var_req_builder = local_var_req_builder
5306            .query(&[("circuit_termination_a__isnull", &local_var_str.to_string())]);
5307    }
5308    if let Some(ref local_var_str) = circuit_termination_a__n {
5309        local_var_req_builder = match "multi" {
5310            "multi" => local_var_req_builder.query(
5311                &local_var_str
5312                    .into_iter()
5313                    .map(|p| ("circuit_termination_a__n".to_owned(), p.to_string()))
5314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5315            ),
5316            _ => local_var_req_builder.query(&[(
5317                "circuit_termination_a__n",
5318                &local_var_str
5319                    .into_iter()
5320                    .map(|p| p.to_string())
5321                    .collect::<Vec<String>>()
5322                    .join(",")
5323                    .to_string(),
5324            )]),
5325        };
5326    }
5327    if let Some(ref local_var_str) = circuit_termination_z {
5328        local_var_req_builder = match "multi" {
5329            "multi" => local_var_req_builder.query(
5330                &local_var_str
5331                    .into_iter()
5332                    .map(|p| ("circuit_termination_z".to_owned(), p.to_string()))
5333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5334            ),
5335            _ => local_var_req_builder.query(&[(
5336                "circuit_termination_z",
5337                &local_var_str
5338                    .into_iter()
5339                    .map(|p| p.to_string())
5340                    .collect::<Vec<String>>()
5341                    .join(",")
5342                    .to_string(),
5343            )]),
5344        };
5345    }
5346    if let Some(ref local_var_str) = circuit_termination_z__isnull {
5347        local_var_req_builder = local_var_req_builder
5348            .query(&[("circuit_termination_z__isnull", &local_var_str.to_string())]);
5349    }
5350    if let Some(ref local_var_str) = circuit_termination_z__n {
5351        local_var_req_builder = match "multi" {
5352            "multi" => local_var_req_builder.query(
5353                &local_var_str
5354                    .into_iter()
5355                    .map(|p| ("circuit_termination_z__n".to_owned(), p.to_string()))
5356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5357            ),
5358            _ => local_var_req_builder.query(&[(
5359                "circuit_termination_z__n",
5360                &local_var_str
5361                    .into_iter()
5362                    .map(|p| p.to_string())
5363                    .collect::<Vec<String>>()
5364                    .join(",")
5365                    .to_string(),
5366            )]),
5367        };
5368    }
5369    if let Some(ref local_var_str) = circuit_terminations {
5370        local_var_req_builder = match "multi" {
5371            "multi" => local_var_req_builder.query(
5372                &local_var_str
5373                    .into_iter()
5374                    .map(|p| ("circuit_terminations".to_owned(), p.to_string()))
5375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5376            ),
5377            _ => local_var_req_builder.query(&[(
5378                "circuit_terminations",
5379                &local_var_str
5380                    .into_iter()
5381                    .map(|p| p.to_string())
5382                    .collect::<Vec<String>>()
5383                    .join(",")
5384                    .to_string(),
5385            )]),
5386        };
5387    }
5388    if let Some(ref local_var_str) = circuit_terminations__isnull {
5389        local_var_req_builder = local_var_req_builder
5390            .query(&[("circuit_terminations__isnull", &local_var_str.to_string())]);
5391    }
5392    if let Some(ref local_var_str) = circuit_terminations__n {
5393        local_var_req_builder = match "multi" {
5394            "multi" => local_var_req_builder.query(
5395                &local_var_str
5396                    .into_iter()
5397                    .map(|p| ("circuit_terminations__n".to_owned(), p.to_string()))
5398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5399            ),
5400            _ => local_var_req_builder.query(&[(
5401                "circuit_terminations__n",
5402                &local_var_str
5403                    .into_iter()
5404                    .map(|p| p.to_string())
5405                    .collect::<Vec<String>>()
5406                    .join(",")
5407                    .to_string(),
5408            )]),
5409        };
5410    }
5411    if let Some(ref local_var_str) = circuit_type {
5412        local_var_req_builder = match "multi" {
5413            "multi" => local_var_req_builder.query(
5414                &local_var_str
5415                    .into_iter()
5416                    .map(|p| ("circuit_type".to_owned(), p.to_string()))
5417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5418            ),
5419            _ => local_var_req_builder.query(&[(
5420                "circuit_type",
5421                &local_var_str
5422                    .into_iter()
5423                    .map(|p| p.to_string())
5424                    .collect::<Vec<String>>()
5425                    .join(",")
5426                    .to_string(),
5427            )]),
5428        };
5429    }
5430    if let Some(ref local_var_str) = circuit_type__n {
5431        local_var_req_builder = match "multi" {
5432            "multi" => local_var_req_builder.query(
5433                &local_var_str
5434                    .into_iter()
5435                    .map(|p| ("circuit_type__n".to_owned(), p.to_string()))
5436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5437            ),
5438            _ => local_var_req_builder.query(&[(
5439                "circuit_type__n",
5440                &local_var_str
5441                    .into_iter()
5442                    .map(|p| p.to_string())
5443                    .collect::<Vec<String>>()
5444                    .join(",")
5445                    .to_string(),
5446            )]),
5447        };
5448    }
5449    if let Some(ref local_var_str) = cloud_network {
5450        local_var_req_builder = match "multi" {
5451            "multi" => local_var_req_builder.query(
5452                &local_var_str
5453                    .into_iter()
5454                    .map(|p| ("cloud_network".to_owned(), p.to_string()))
5455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5456            ),
5457            _ => local_var_req_builder.query(&[(
5458                "cloud_network",
5459                &local_var_str
5460                    .into_iter()
5461                    .map(|p| p.to_string())
5462                    .collect::<Vec<String>>()
5463                    .join(",")
5464                    .to_string(),
5465            )]),
5466        };
5467    }
5468    if let Some(ref local_var_str) = cloud_network__isnull {
5469        local_var_req_builder =
5470            local_var_req_builder.query(&[("cloud_network__isnull", &local_var_str.to_string())]);
5471    }
5472    if let Some(ref local_var_str) = cloud_network__n {
5473        local_var_req_builder = match "multi" {
5474            "multi" => local_var_req_builder.query(
5475                &local_var_str
5476                    .into_iter()
5477                    .map(|p| ("cloud_network__n".to_owned(), p.to_string()))
5478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5479            ),
5480            _ => local_var_req_builder.query(&[(
5481                "cloud_network__n",
5482                &local_var_str
5483                    .into_iter()
5484                    .map(|p| p.to_string())
5485                    .collect::<Vec<String>>()
5486                    .join(",")
5487                    .to_string(),
5488            )]),
5489        };
5490    }
5491    if let Some(ref local_var_str) = comments {
5492        local_var_req_builder = match "multi" {
5493            "multi" => local_var_req_builder.query(
5494                &local_var_str
5495                    .into_iter()
5496                    .map(|p| ("comments".to_owned(), p.to_string()))
5497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5498            ),
5499            _ => local_var_req_builder.query(&[(
5500                "comments",
5501                &local_var_str
5502                    .into_iter()
5503                    .map(|p| p.to_string())
5504                    .collect::<Vec<String>>()
5505                    .join(",")
5506                    .to_string(),
5507            )]),
5508        };
5509    }
5510    if let Some(ref local_var_str) = comments__ic {
5511        local_var_req_builder = match "multi" {
5512            "multi" => local_var_req_builder.query(
5513                &local_var_str
5514                    .into_iter()
5515                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
5516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5517            ),
5518            _ => local_var_req_builder.query(&[(
5519                "comments__ic",
5520                &local_var_str
5521                    .into_iter()
5522                    .map(|p| p.to_string())
5523                    .collect::<Vec<String>>()
5524                    .join(",")
5525                    .to_string(),
5526            )]),
5527        };
5528    }
5529    if let Some(ref local_var_str) = comments__ie {
5530        local_var_req_builder = match "multi" {
5531            "multi" => local_var_req_builder.query(
5532                &local_var_str
5533                    .into_iter()
5534                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
5535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5536            ),
5537            _ => local_var_req_builder.query(&[(
5538                "comments__ie",
5539                &local_var_str
5540                    .into_iter()
5541                    .map(|p| p.to_string())
5542                    .collect::<Vec<String>>()
5543                    .join(",")
5544                    .to_string(),
5545            )]),
5546        };
5547    }
5548    if let Some(ref local_var_str) = comments__iew {
5549        local_var_req_builder = match "multi" {
5550            "multi" => local_var_req_builder.query(
5551                &local_var_str
5552                    .into_iter()
5553                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
5554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5555            ),
5556            _ => local_var_req_builder.query(&[(
5557                "comments__iew",
5558                &local_var_str
5559                    .into_iter()
5560                    .map(|p| p.to_string())
5561                    .collect::<Vec<String>>()
5562                    .join(",")
5563                    .to_string(),
5564            )]),
5565        };
5566    }
5567    if let Some(ref local_var_str) = comments__ire {
5568        local_var_req_builder = match "multi" {
5569            "multi" => local_var_req_builder.query(
5570                &local_var_str
5571                    .into_iter()
5572                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
5573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5574            ),
5575            _ => local_var_req_builder.query(&[(
5576                "comments__ire",
5577                &local_var_str
5578                    .into_iter()
5579                    .map(|p| p.to_string())
5580                    .collect::<Vec<String>>()
5581                    .join(",")
5582                    .to_string(),
5583            )]),
5584        };
5585    }
5586    if let Some(ref local_var_str) = comments__isw {
5587        local_var_req_builder = match "multi" {
5588            "multi" => local_var_req_builder.query(
5589                &local_var_str
5590                    .into_iter()
5591                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
5592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5593            ),
5594            _ => local_var_req_builder.query(&[(
5595                "comments__isw",
5596                &local_var_str
5597                    .into_iter()
5598                    .map(|p| p.to_string())
5599                    .collect::<Vec<String>>()
5600                    .join(",")
5601                    .to_string(),
5602            )]),
5603        };
5604    }
5605    if let Some(ref local_var_str) = comments__n {
5606        local_var_req_builder = match "multi" {
5607            "multi" => local_var_req_builder.query(
5608                &local_var_str
5609                    .into_iter()
5610                    .map(|p| ("comments__n".to_owned(), p.to_string()))
5611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5612            ),
5613            _ => local_var_req_builder.query(&[(
5614                "comments__n",
5615                &local_var_str
5616                    .into_iter()
5617                    .map(|p| p.to_string())
5618                    .collect::<Vec<String>>()
5619                    .join(",")
5620                    .to_string(),
5621            )]),
5622        };
5623    }
5624    if let Some(ref local_var_str) = comments__nic {
5625        local_var_req_builder = match "multi" {
5626            "multi" => local_var_req_builder.query(
5627                &local_var_str
5628                    .into_iter()
5629                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
5630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5631            ),
5632            _ => local_var_req_builder.query(&[(
5633                "comments__nic",
5634                &local_var_str
5635                    .into_iter()
5636                    .map(|p| p.to_string())
5637                    .collect::<Vec<String>>()
5638                    .join(",")
5639                    .to_string(),
5640            )]),
5641        };
5642    }
5643    if let Some(ref local_var_str) = comments__nie {
5644        local_var_req_builder = match "multi" {
5645            "multi" => local_var_req_builder.query(
5646                &local_var_str
5647                    .into_iter()
5648                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
5649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5650            ),
5651            _ => local_var_req_builder.query(&[(
5652                "comments__nie",
5653                &local_var_str
5654                    .into_iter()
5655                    .map(|p| p.to_string())
5656                    .collect::<Vec<String>>()
5657                    .join(",")
5658                    .to_string(),
5659            )]),
5660        };
5661    }
5662    if let Some(ref local_var_str) = comments__niew {
5663        local_var_req_builder = match "multi" {
5664            "multi" => local_var_req_builder.query(
5665                &local_var_str
5666                    .into_iter()
5667                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
5668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5669            ),
5670            _ => local_var_req_builder.query(&[(
5671                "comments__niew",
5672                &local_var_str
5673                    .into_iter()
5674                    .map(|p| p.to_string())
5675                    .collect::<Vec<String>>()
5676                    .join(",")
5677                    .to_string(),
5678            )]),
5679        };
5680    }
5681    if let Some(ref local_var_str) = comments__nire {
5682        local_var_req_builder = match "multi" {
5683            "multi" => local_var_req_builder.query(
5684                &local_var_str
5685                    .into_iter()
5686                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
5687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5688            ),
5689            _ => local_var_req_builder.query(&[(
5690                "comments__nire",
5691                &local_var_str
5692                    .into_iter()
5693                    .map(|p| p.to_string())
5694                    .collect::<Vec<String>>()
5695                    .join(",")
5696                    .to_string(),
5697            )]),
5698        };
5699    }
5700    if let Some(ref local_var_str) = comments__nisw {
5701        local_var_req_builder = match "multi" {
5702            "multi" => local_var_req_builder.query(
5703                &local_var_str
5704                    .into_iter()
5705                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
5706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5707            ),
5708            _ => local_var_req_builder.query(&[(
5709                "comments__nisw",
5710                &local_var_str
5711                    .into_iter()
5712                    .map(|p| p.to_string())
5713                    .collect::<Vec<String>>()
5714                    .join(",")
5715                    .to_string(),
5716            )]),
5717        };
5718    }
5719    if let Some(ref local_var_str) = comments__nre {
5720        local_var_req_builder = match "multi" {
5721            "multi" => local_var_req_builder.query(
5722                &local_var_str
5723                    .into_iter()
5724                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
5725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5726            ),
5727            _ => local_var_req_builder.query(&[(
5728                "comments__nre",
5729                &local_var_str
5730                    .into_iter()
5731                    .map(|p| p.to_string())
5732                    .collect::<Vec<String>>()
5733                    .join(",")
5734                    .to_string(),
5735            )]),
5736        };
5737    }
5738    if let Some(ref local_var_str) = comments__re {
5739        local_var_req_builder = match "multi" {
5740            "multi" => local_var_req_builder.query(
5741                &local_var_str
5742                    .into_iter()
5743                    .map(|p| ("comments__re".to_owned(), p.to_string()))
5744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5745            ),
5746            _ => local_var_req_builder.query(&[(
5747                "comments__re",
5748                &local_var_str
5749                    .into_iter()
5750                    .map(|p| p.to_string())
5751                    .collect::<Vec<String>>()
5752                    .join(",")
5753                    .to_string(),
5754            )]),
5755        };
5756    }
5757    if let Some(ref local_var_str) = commit_rate {
5758        local_var_req_builder = match "multi" {
5759            "multi" => local_var_req_builder.query(
5760                &local_var_str
5761                    .into_iter()
5762                    .map(|p| ("commit_rate".to_owned(), p.to_string()))
5763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5764            ),
5765            _ => local_var_req_builder.query(&[(
5766                "commit_rate",
5767                &local_var_str
5768                    .into_iter()
5769                    .map(|p| p.to_string())
5770                    .collect::<Vec<String>>()
5771                    .join(",")
5772                    .to_string(),
5773            )]),
5774        };
5775    }
5776    if let Some(ref local_var_str) = commit_rate__gt {
5777        local_var_req_builder = match "multi" {
5778            "multi" => local_var_req_builder.query(
5779                &local_var_str
5780                    .into_iter()
5781                    .map(|p| ("commit_rate__gt".to_owned(), p.to_string()))
5782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5783            ),
5784            _ => local_var_req_builder.query(&[(
5785                "commit_rate__gt",
5786                &local_var_str
5787                    .into_iter()
5788                    .map(|p| p.to_string())
5789                    .collect::<Vec<String>>()
5790                    .join(",")
5791                    .to_string(),
5792            )]),
5793        };
5794    }
5795    if let Some(ref local_var_str) = commit_rate__gte {
5796        local_var_req_builder = match "multi" {
5797            "multi" => local_var_req_builder.query(
5798                &local_var_str
5799                    .into_iter()
5800                    .map(|p| ("commit_rate__gte".to_owned(), p.to_string()))
5801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5802            ),
5803            _ => local_var_req_builder.query(&[(
5804                "commit_rate__gte",
5805                &local_var_str
5806                    .into_iter()
5807                    .map(|p| p.to_string())
5808                    .collect::<Vec<String>>()
5809                    .join(",")
5810                    .to_string(),
5811            )]),
5812        };
5813    }
5814    if let Some(ref local_var_str) = commit_rate__isnull {
5815        local_var_req_builder =
5816            local_var_req_builder.query(&[("commit_rate__isnull", &local_var_str.to_string())]);
5817    }
5818    if let Some(ref local_var_str) = commit_rate__lt {
5819        local_var_req_builder = match "multi" {
5820            "multi" => local_var_req_builder.query(
5821                &local_var_str
5822                    .into_iter()
5823                    .map(|p| ("commit_rate__lt".to_owned(), p.to_string()))
5824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5825            ),
5826            _ => local_var_req_builder.query(&[(
5827                "commit_rate__lt",
5828                &local_var_str
5829                    .into_iter()
5830                    .map(|p| p.to_string())
5831                    .collect::<Vec<String>>()
5832                    .join(",")
5833                    .to_string(),
5834            )]),
5835        };
5836    }
5837    if let Some(ref local_var_str) = commit_rate__lte {
5838        local_var_req_builder = match "multi" {
5839            "multi" => local_var_req_builder.query(
5840                &local_var_str
5841                    .into_iter()
5842                    .map(|p| ("commit_rate__lte".to_owned(), p.to_string()))
5843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5844            ),
5845            _ => local_var_req_builder.query(&[(
5846                "commit_rate__lte",
5847                &local_var_str
5848                    .into_iter()
5849                    .map(|p| p.to_string())
5850                    .collect::<Vec<String>>()
5851                    .join(",")
5852                    .to_string(),
5853            )]),
5854        };
5855    }
5856    if let Some(ref local_var_str) = commit_rate__n {
5857        local_var_req_builder = match "multi" {
5858            "multi" => local_var_req_builder.query(
5859                &local_var_str
5860                    .into_iter()
5861                    .map(|p| ("commit_rate__n".to_owned(), p.to_string()))
5862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5863            ),
5864            _ => local_var_req_builder.query(&[(
5865                "commit_rate__n",
5866                &local_var_str
5867                    .into_iter()
5868                    .map(|p| p.to_string())
5869                    .collect::<Vec<String>>()
5870                    .join(",")
5871                    .to_string(),
5872            )]),
5873        };
5874    }
5875    if let Some(ref local_var_str) = contacts {
5876        local_var_req_builder = match "multi" {
5877            "multi" => local_var_req_builder.query(
5878                &local_var_str
5879                    .into_iter()
5880                    .map(|p| ("contacts".to_owned(), p.to_string()))
5881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5882            ),
5883            _ => local_var_req_builder.query(&[(
5884                "contacts",
5885                &local_var_str
5886                    .into_iter()
5887                    .map(|p| p.to_string())
5888                    .collect::<Vec<String>>()
5889                    .join(",")
5890                    .to_string(),
5891            )]),
5892        };
5893    }
5894    if let Some(ref local_var_str) = contacts__isnull {
5895        local_var_req_builder =
5896            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
5897    }
5898    if let Some(ref local_var_str) = contacts__n {
5899        local_var_req_builder = match "multi" {
5900            "multi" => local_var_req_builder.query(
5901                &local_var_str
5902                    .into_iter()
5903                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
5904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5905            ),
5906            _ => local_var_req_builder.query(&[(
5907                "contacts__n",
5908                &local_var_str
5909                    .into_iter()
5910                    .map(|p| p.to_string())
5911                    .collect::<Vec<String>>()
5912                    .join(",")
5913                    .to_string(),
5914            )]),
5915        };
5916    }
5917    if let Some(ref local_var_str) = created {
5918        local_var_req_builder = match "multi" {
5919            "multi" => local_var_req_builder.query(
5920                &local_var_str
5921                    .into_iter()
5922                    .map(|p| ("created".to_owned(), p.to_string()))
5923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5924            ),
5925            _ => local_var_req_builder.query(&[(
5926                "created",
5927                &local_var_str
5928                    .into_iter()
5929                    .map(|p| p.to_string())
5930                    .collect::<Vec<String>>()
5931                    .join(",")
5932                    .to_string(),
5933            )]),
5934        };
5935    }
5936    if let Some(ref local_var_str) = created__gt {
5937        local_var_req_builder = match "multi" {
5938            "multi" => local_var_req_builder.query(
5939                &local_var_str
5940                    .into_iter()
5941                    .map(|p| ("created__gt".to_owned(), p.to_string()))
5942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5943            ),
5944            _ => local_var_req_builder.query(&[(
5945                "created__gt",
5946                &local_var_str
5947                    .into_iter()
5948                    .map(|p| p.to_string())
5949                    .collect::<Vec<String>>()
5950                    .join(",")
5951                    .to_string(),
5952            )]),
5953        };
5954    }
5955    if let Some(ref local_var_str) = created__gte {
5956        local_var_req_builder = match "multi" {
5957            "multi" => local_var_req_builder.query(
5958                &local_var_str
5959                    .into_iter()
5960                    .map(|p| ("created__gte".to_owned(), p.to_string()))
5961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5962            ),
5963            _ => local_var_req_builder.query(&[(
5964                "created__gte",
5965                &local_var_str
5966                    .into_iter()
5967                    .map(|p| p.to_string())
5968                    .collect::<Vec<String>>()
5969                    .join(",")
5970                    .to_string(),
5971            )]),
5972        };
5973    }
5974    if let Some(ref local_var_str) = created__isnull {
5975        local_var_req_builder =
5976            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
5977    }
5978    if let Some(ref local_var_str) = created__lt {
5979        local_var_req_builder = match "multi" {
5980            "multi" => local_var_req_builder.query(
5981                &local_var_str
5982                    .into_iter()
5983                    .map(|p| ("created__lt".to_owned(), p.to_string()))
5984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5985            ),
5986            _ => local_var_req_builder.query(&[(
5987                "created__lt",
5988                &local_var_str
5989                    .into_iter()
5990                    .map(|p| p.to_string())
5991                    .collect::<Vec<String>>()
5992                    .join(",")
5993                    .to_string(),
5994            )]),
5995        };
5996    }
5997    if let Some(ref local_var_str) = created__lte {
5998        local_var_req_builder = match "multi" {
5999            "multi" => local_var_req_builder.query(
6000                &local_var_str
6001                    .into_iter()
6002                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6004            ),
6005            _ => local_var_req_builder.query(&[(
6006                "created__lte",
6007                &local_var_str
6008                    .into_iter()
6009                    .map(|p| p.to_string())
6010                    .collect::<Vec<String>>()
6011                    .join(",")
6012                    .to_string(),
6013            )]),
6014        };
6015    }
6016    if let Some(ref local_var_str) = created__n {
6017        local_var_req_builder = match "multi" {
6018            "multi" => local_var_req_builder.query(
6019                &local_var_str
6020                    .into_iter()
6021                    .map(|p| ("created__n".to_owned(), p.to_string()))
6022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6023            ),
6024            _ => local_var_req_builder.query(&[(
6025                "created__n",
6026                &local_var_str
6027                    .into_iter()
6028                    .map(|p| p.to_string())
6029                    .collect::<Vec<String>>()
6030                    .join(",")
6031                    .to_string(),
6032            )]),
6033        };
6034    }
6035    if let Some(ref local_var_str) = description {
6036        local_var_req_builder = match "multi" {
6037            "multi" => local_var_req_builder.query(
6038                &local_var_str
6039                    .into_iter()
6040                    .map(|p| ("description".to_owned(), p.to_string()))
6041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6042            ),
6043            _ => local_var_req_builder.query(&[(
6044                "description",
6045                &local_var_str
6046                    .into_iter()
6047                    .map(|p| p.to_string())
6048                    .collect::<Vec<String>>()
6049                    .join(",")
6050                    .to_string(),
6051            )]),
6052        };
6053    }
6054    if let Some(ref local_var_str) = description__ic {
6055        local_var_req_builder = match "multi" {
6056            "multi" => local_var_req_builder.query(
6057                &local_var_str
6058                    .into_iter()
6059                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6061            ),
6062            _ => local_var_req_builder.query(&[(
6063                "description__ic",
6064                &local_var_str
6065                    .into_iter()
6066                    .map(|p| p.to_string())
6067                    .collect::<Vec<String>>()
6068                    .join(",")
6069                    .to_string(),
6070            )]),
6071        };
6072    }
6073    if let Some(ref local_var_str) = description__ie {
6074        local_var_req_builder = match "multi" {
6075            "multi" => local_var_req_builder.query(
6076                &local_var_str
6077                    .into_iter()
6078                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6080            ),
6081            _ => local_var_req_builder.query(&[(
6082                "description__ie",
6083                &local_var_str
6084                    .into_iter()
6085                    .map(|p| p.to_string())
6086                    .collect::<Vec<String>>()
6087                    .join(",")
6088                    .to_string(),
6089            )]),
6090        };
6091    }
6092    if let Some(ref local_var_str) = description__iew {
6093        local_var_req_builder = match "multi" {
6094            "multi" => local_var_req_builder.query(
6095                &local_var_str
6096                    .into_iter()
6097                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6099            ),
6100            _ => local_var_req_builder.query(&[(
6101                "description__iew",
6102                &local_var_str
6103                    .into_iter()
6104                    .map(|p| p.to_string())
6105                    .collect::<Vec<String>>()
6106                    .join(",")
6107                    .to_string(),
6108            )]),
6109        };
6110    }
6111    if let Some(ref local_var_str) = description__ire {
6112        local_var_req_builder = match "multi" {
6113            "multi" => local_var_req_builder.query(
6114                &local_var_str
6115                    .into_iter()
6116                    .map(|p| ("description__ire".to_owned(), p.to_string()))
6117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6118            ),
6119            _ => local_var_req_builder.query(&[(
6120                "description__ire",
6121                &local_var_str
6122                    .into_iter()
6123                    .map(|p| p.to_string())
6124                    .collect::<Vec<String>>()
6125                    .join(",")
6126                    .to_string(),
6127            )]),
6128        };
6129    }
6130    if let Some(ref local_var_str) = description__isw {
6131        local_var_req_builder = match "multi" {
6132            "multi" => local_var_req_builder.query(
6133                &local_var_str
6134                    .into_iter()
6135                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6137            ),
6138            _ => local_var_req_builder.query(&[(
6139                "description__isw",
6140                &local_var_str
6141                    .into_iter()
6142                    .map(|p| p.to_string())
6143                    .collect::<Vec<String>>()
6144                    .join(",")
6145                    .to_string(),
6146            )]),
6147        };
6148    }
6149    if let Some(ref local_var_str) = description__n {
6150        local_var_req_builder = match "multi" {
6151            "multi" => local_var_req_builder.query(
6152                &local_var_str
6153                    .into_iter()
6154                    .map(|p| ("description__n".to_owned(), p.to_string()))
6155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6156            ),
6157            _ => local_var_req_builder.query(&[(
6158                "description__n",
6159                &local_var_str
6160                    .into_iter()
6161                    .map(|p| p.to_string())
6162                    .collect::<Vec<String>>()
6163                    .join(",")
6164                    .to_string(),
6165            )]),
6166        };
6167    }
6168    if let Some(ref local_var_str) = description__nic {
6169        local_var_req_builder = match "multi" {
6170            "multi" => local_var_req_builder.query(
6171                &local_var_str
6172                    .into_iter()
6173                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6175            ),
6176            _ => local_var_req_builder.query(&[(
6177                "description__nic",
6178                &local_var_str
6179                    .into_iter()
6180                    .map(|p| p.to_string())
6181                    .collect::<Vec<String>>()
6182                    .join(",")
6183                    .to_string(),
6184            )]),
6185        };
6186    }
6187    if let Some(ref local_var_str) = description__nie {
6188        local_var_req_builder = match "multi" {
6189            "multi" => local_var_req_builder.query(
6190                &local_var_str
6191                    .into_iter()
6192                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6194            ),
6195            _ => local_var_req_builder.query(&[(
6196                "description__nie",
6197                &local_var_str
6198                    .into_iter()
6199                    .map(|p| p.to_string())
6200                    .collect::<Vec<String>>()
6201                    .join(",")
6202                    .to_string(),
6203            )]),
6204        };
6205    }
6206    if let Some(ref local_var_str) = description__niew {
6207        local_var_req_builder = match "multi" {
6208            "multi" => local_var_req_builder.query(
6209                &local_var_str
6210                    .into_iter()
6211                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6213            ),
6214            _ => local_var_req_builder.query(&[(
6215                "description__niew",
6216                &local_var_str
6217                    .into_iter()
6218                    .map(|p| p.to_string())
6219                    .collect::<Vec<String>>()
6220                    .join(",")
6221                    .to_string(),
6222            )]),
6223        };
6224    }
6225    if let Some(ref local_var_str) = description__nire {
6226        local_var_req_builder = match "multi" {
6227            "multi" => local_var_req_builder.query(
6228                &local_var_str
6229                    .into_iter()
6230                    .map(|p| ("description__nire".to_owned(), p.to_string()))
6231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6232            ),
6233            _ => local_var_req_builder.query(&[(
6234                "description__nire",
6235                &local_var_str
6236                    .into_iter()
6237                    .map(|p| p.to_string())
6238                    .collect::<Vec<String>>()
6239                    .join(",")
6240                    .to_string(),
6241            )]),
6242        };
6243    }
6244    if let Some(ref local_var_str) = description__nisw {
6245        local_var_req_builder = match "multi" {
6246            "multi" => local_var_req_builder.query(
6247                &local_var_str
6248                    .into_iter()
6249                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6250                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6251            ),
6252            _ => local_var_req_builder.query(&[(
6253                "description__nisw",
6254                &local_var_str
6255                    .into_iter()
6256                    .map(|p| p.to_string())
6257                    .collect::<Vec<String>>()
6258                    .join(",")
6259                    .to_string(),
6260            )]),
6261        };
6262    }
6263    if let Some(ref local_var_str) = description__nre {
6264        local_var_req_builder = match "multi" {
6265            "multi" => local_var_req_builder.query(
6266                &local_var_str
6267                    .into_iter()
6268                    .map(|p| ("description__nre".to_owned(), p.to_string()))
6269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6270            ),
6271            _ => local_var_req_builder.query(&[(
6272                "description__nre",
6273                &local_var_str
6274                    .into_iter()
6275                    .map(|p| p.to_string())
6276                    .collect::<Vec<String>>()
6277                    .join(",")
6278                    .to_string(),
6279            )]),
6280        };
6281    }
6282    if let Some(ref local_var_str) = description__re {
6283        local_var_req_builder = match "multi" {
6284            "multi" => local_var_req_builder.query(
6285                &local_var_str
6286                    .into_iter()
6287                    .map(|p| ("description__re".to_owned(), p.to_string()))
6288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6289            ),
6290            _ => local_var_req_builder.query(&[(
6291                "description__re",
6292                &local_var_str
6293                    .into_iter()
6294                    .map(|p| p.to_string())
6295                    .collect::<Vec<String>>()
6296                    .join(",")
6297                    .to_string(),
6298            )]),
6299        };
6300    }
6301    if let Some(ref local_var_str) = dynamic_groups {
6302        local_var_req_builder = match "multi" {
6303            "multi" => local_var_req_builder.query(
6304                &local_var_str
6305                    .into_iter()
6306                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
6307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6308            ),
6309            _ => local_var_req_builder.query(&[(
6310                "dynamic_groups",
6311                &local_var_str
6312                    .into_iter()
6313                    .map(|p| p.to_string())
6314                    .collect::<Vec<String>>()
6315                    .join(",")
6316                    .to_string(),
6317            )]),
6318        };
6319    }
6320    if let Some(ref local_var_str) = dynamic_groups__n {
6321        local_var_req_builder = match "multi" {
6322            "multi" => local_var_req_builder.query(
6323                &local_var_str
6324                    .into_iter()
6325                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
6326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6327            ),
6328            _ => local_var_req_builder.query(&[(
6329                "dynamic_groups__n",
6330                &local_var_str
6331                    .into_iter()
6332                    .map(|p| p.to_string())
6333                    .collect::<Vec<String>>()
6334                    .join(",")
6335                    .to_string(),
6336            )]),
6337        };
6338    }
6339    if let Some(ref local_var_str) = format {
6340        local_var_req_builder =
6341            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6342    }
6343    if let Some(ref local_var_str) = has_terminations {
6344        local_var_req_builder =
6345            local_var_req_builder.query(&[("has_terminations", &local_var_str.to_string())]);
6346    }
6347    if let Some(ref local_var_str) = id {
6348        local_var_req_builder = match "multi" {
6349            "multi" => local_var_req_builder.query(
6350                &local_var_str
6351                    .into_iter()
6352                    .map(|p| ("id".to_owned(), p.to_string()))
6353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6354            ),
6355            _ => local_var_req_builder.query(&[(
6356                "id",
6357                &local_var_str
6358                    .into_iter()
6359                    .map(|p| p.to_string())
6360                    .collect::<Vec<String>>()
6361                    .join(",")
6362                    .to_string(),
6363            )]),
6364        };
6365    }
6366    if let Some(ref local_var_str) = id__n {
6367        local_var_req_builder = match "multi" {
6368            "multi" => local_var_req_builder.query(
6369                &local_var_str
6370                    .into_iter()
6371                    .map(|p| ("id__n".to_owned(), p.to_string()))
6372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6373            ),
6374            _ => local_var_req_builder.query(&[(
6375                "id__n",
6376                &local_var_str
6377                    .into_iter()
6378                    .map(|p| p.to_string())
6379                    .collect::<Vec<String>>()
6380                    .join(",")
6381                    .to_string(),
6382            )]),
6383        };
6384    }
6385    if let Some(ref local_var_str) = install_date {
6386        local_var_req_builder = match "multi" {
6387            "multi" => local_var_req_builder.query(
6388                &local_var_str
6389                    .into_iter()
6390                    .map(|p| ("install_date".to_owned(), p.to_string()))
6391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6392            ),
6393            _ => local_var_req_builder.query(&[(
6394                "install_date",
6395                &local_var_str
6396                    .into_iter()
6397                    .map(|p| p.to_string())
6398                    .collect::<Vec<String>>()
6399                    .join(",")
6400                    .to_string(),
6401            )]),
6402        };
6403    }
6404    if let Some(ref local_var_str) = install_date__gt {
6405        local_var_req_builder = match "multi" {
6406            "multi" => local_var_req_builder.query(
6407                &local_var_str
6408                    .into_iter()
6409                    .map(|p| ("install_date__gt".to_owned(), p.to_string()))
6410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6411            ),
6412            _ => local_var_req_builder.query(&[(
6413                "install_date__gt",
6414                &local_var_str
6415                    .into_iter()
6416                    .map(|p| p.to_string())
6417                    .collect::<Vec<String>>()
6418                    .join(",")
6419                    .to_string(),
6420            )]),
6421        };
6422    }
6423    if let Some(ref local_var_str) = install_date__gte {
6424        local_var_req_builder = match "multi" {
6425            "multi" => local_var_req_builder.query(
6426                &local_var_str
6427                    .into_iter()
6428                    .map(|p| ("install_date__gte".to_owned(), p.to_string()))
6429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6430            ),
6431            _ => local_var_req_builder.query(&[(
6432                "install_date__gte",
6433                &local_var_str
6434                    .into_iter()
6435                    .map(|p| p.to_string())
6436                    .collect::<Vec<String>>()
6437                    .join(",")
6438                    .to_string(),
6439            )]),
6440        };
6441    }
6442    if let Some(ref local_var_str) = install_date__isnull {
6443        local_var_req_builder =
6444            local_var_req_builder.query(&[("install_date__isnull", &local_var_str.to_string())]);
6445    }
6446    if let Some(ref local_var_str) = install_date__lt {
6447        local_var_req_builder = match "multi" {
6448            "multi" => local_var_req_builder.query(
6449                &local_var_str
6450                    .into_iter()
6451                    .map(|p| ("install_date__lt".to_owned(), p.to_string()))
6452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6453            ),
6454            _ => local_var_req_builder.query(&[(
6455                "install_date__lt",
6456                &local_var_str
6457                    .into_iter()
6458                    .map(|p| p.to_string())
6459                    .collect::<Vec<String>>()
6460                    .join(",")
6461                    .to_string(),
6462            )]),
6463        };
6464    }
6465    if let Some(ref local_var_str) = install_date__lte {
6466        local_var_req_builder = match "multi" {
6467            "multi" => local_var_req_builder.query(
6468                &local_var_str
6469                    .into_iter()
6470                    .map(|p| ("install_date__lte".to_owned(), p.to_string()))
6471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6472            ),
6473            _ => local_var_req_builder.query(&[(
6474                "install_date__lte",
6475                &local_var_str
6476                    .into_iter()
6477                    .map(|p| p.to_string())
6478                    .collect::<Vec<String>>()
6479                    .join(",")
6480                    .to_string(),
6481            )]),
6482        };
6483    }
6484    if let Some(ref local_var_str) = install_date__n {
6485        local_var_req_builder = match "multi" {
6486            "multi" => local_var_req_builder.query(
6487                &local_var_str
6488                    .into_iter()
6489                    .map(|p| ("install_date__n".to_owned(), p.to_string()))
6490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6491            ),
6492            _ => local_var_req_builder.query(&[(
6493                "install_date__n",
6494                &local_var_str
6495                    .into_iter()
6496                    .map(|p| p.to_string())
6497                    .collect::<Vec<String>>()
6498                    .join(",")
6499                    .to_string(),
6500            )]),
6501        };
6502    }
6503    if let Some(ref local_var_str) = last_updated {
6504        local_var_req_builder = match "multi" {
6505            "multi" => local_var_req_builder.query(
6506                &local_var_str
6507                    .into_iter()
6508                    .map(|p| ("last_updated".to_owned(), p.to_string()))
6509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6510            ),
6511            _ => local_var_req_builder.query(&[(
6512                "last_updated",
6513                &local_var_str
6514                    .into_iter()
6515                    .map(|p| p.to_string())
6516                    .collect::<Vec<String>>()
6517                    .join(",")
6518                    .to_string(),
6519            )]),
6520        };
6521    }
6522    if let Some(ref local_var_str) = last_updated__gt {
6523        local_var_req_builder = match "multi" {
6524            "multi" => local_var_req_builder.query(
6525                &local_var_str
6526                    .into_iter()
6527                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
6528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6529            ),
6530            _ => local_var_req_builder.query(&[(
6531                "last_updated__gt",
6532                &local_var_str
6533                    .into_iter()
6534                    .map(|p| p.to_string())
6535                    .collect::<Vec<String>>()
6536                    .join(",")
6537                    .to_string(),
6538            )]),
6539        };
6540    }
6541    if let Some(ref local_var_str) = last_updated__gte {
6542        local_var_req_builder = match "multi" {
6543            "multi" => local_var_req_builder.query(
6544                &local_var_str
6545                    .into_iter()
6546                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
6547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6548            ),
6549            _ => local_var_req_builder.query(&[(
6550                "last_updated__gte",
6551                &local_var_str
6552                    .into_iter()
6553                    .map(|p| p.to_string())
6554                    .collect::<Vec<String>>()
6555                    .join(",")
6556                    .to_string(),
6557            )]),
6558        };
6559    }
6560    if let Some(ref local_var_str) = last_updated__isnull {
6561        local_var_req_builder =
6562            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
6563    }
6564    if let Some(ref local_var_str) = last_updated__lt {
6565        local_var_req_builder = match "multi" {
6566            "multi" => local_var_req_builder.query(
6567                &local_var_str
6568                    .into_iter()
6569                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
6570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6571            ),
6572            _ => local_var_req_builder.query(&[(
6573                "last_updated__lt",
6574                &local_var_str
6575                    .into_iter()
6576                    .map(|p| p.to_string())
6577                    .collect::<Vec<String>>()
6578                    .join(",")
6579                    .to_string(),
6580            )]),
6581        };
6582    }
6583    if let Some(ref local_var_str) = last_updated__lte {
6584        local_var_req_builder = match "multi" {
6585            "multi" => local_var_req_builder.query(
6586                &local_var_str
6587                    .into_iter()
6588                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
6589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6590            ),
6591            _ => local_var_req_builder.query(&[(
6592                "last_updated__lte",
6593                &local_var_str
6594                    .into_iter()
6595                    .map(|p| p.to_string())
6596                    .collect::<Vec<String>>()
6597                    .join(",")
6598                    .to_string(),
6599            )]),
6600        };
6601    }
6602    if let Some(ref local_var_str) = last_updated__n {
6603        local_var_req_builder = match "multi" {
6604            "multi" => local_var_req_builder.query(
6605                &local_var_str
6606                    .into_iter()
6607                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
6608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6609            ),
6610            _ => local_var_req_builder.query(&[(
6611                "last_updated__n",
6612                &local_var_str
6613                    .into_iter()
6614                    .map(|p| p.to_string())
6615                    .collect::<Vec<String>>()
6616                    .join(",")
6617                    .to_string(),
6618            )]),
6619        };
6620    }
6621    if let Some(ref local_var_str) = limit {
6622        local_var_req_builder =
6623            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6624    }
6625    if let Some(ref local_var_str) = location {
6626        local_var_req_builder = match "multi" {
6627            "multi" => local_var_req_builder.query(
6628                &local_var_str
6629                    .into_iter()
6630                    .map(|p| ("location".to_owned(), p.to_string()))
6631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6632            ),
6633            _ => local_var_req_builder.query(&[(
6634                "location",
6635                &local_var_str
6636                    .into_iter()
6637                    .map(|p| p.to_string())
6638                    .collect::<Vec<String>>()
6639                    .join(",")
6640                    .to_string(),
6641            )]),
6642        };
6643    }
6644    if let Some(ref local_var_str) = location__isnull {
6645        local_var_req_builder =
6646            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
6647    }
6648    if let Some(ref local_var_str) = location__n {
6649        local_var_req_builder = match "multi" {
6650            "multi" => local_var_req_builder.query(
6651                &local_var_str
6652                    .into_iter()
6653                    .map(|p| ("location__n".to_owned(), p.to_string()))
6654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6655            ),
6656            _ => local_var_req_builder.query(&[(
6657                "location__n",
6658                &local_var_str
6659                    .into_iter()
6660                    .map(|p| p.to_string())
6661                    .collect::<Vec<String>>()
6662                    .join(",")
6663                    .to_string(),
6664            )]),
6665        };
6666    }
6667    if let Some(ref local_var_str) = offset {
6668        local_var_req_builder =
6669            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6670    }
6671    if let Some(ref local_var_str) = provider {
6672        local_var_req_builder = match "multi" {
6673            "multi" => local_var_req_builder.query(
6674                &local_var_str
6675                    .into_iter()
6676                    .map(|p| ("provider".to_owned(), p.to_string()))
6677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6678            ),
6679            _ => local_var_req_builder.query(&[(
6680                "provider",
6681                &local_var_str
6682                    .into_iter()
6683                    .map(|p| p.to_string())
6684                    .collect::<Vec<String>>()
6685                    .join(",")
6686                    .to_string(),
6687            )]),
6688        };
6689    }
6690    if let Some(ref local_var_str) = provider__n {
6691        local_var_req_builder = match "multi" {
6692            "multi" => local_var_req_builder.query(
6693                &local_var_str
6694                    .into_iter()
6695                    .map(|p| ("provider__n".to_owned(), p.to_string()))
6696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6697            ),
6698            _ => local_var_req_builder.query(&[(
6699                "provider__n",
6700                &local_var_str
6701                    .into_iter()
6702                    .map(|p| p.to_string())
6703                    .collect::<Vec<String>>()
6704                    .join(",")
6705                    .to_string(),
6706            )]),
6707        };
6708    }
6709    if let Some(ref local_var_str) = provider_network {
6710        local_var_req_builder = match "multi" {
6711            "multi" => local_var_req_builder.query(
6712                &local_var_str
6713                    .into_iter()
6714                    .map(|p| ("provider_network".to_owned(), p.to_string()))
6715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6716            ),
6717            _ => local_var_req_builder.query(&[(
6718                "provider_network",
6719                &local_var_str
6720                    .into_iter()
6721                    .map(|p| p.to_string())
6722                    .collect::<Vec<String>>()
6723                    .join(",")
6724                    .to_string(),
6725            )]),
6726        };
6727    }
6728    if let Some(ref local_var_str) = provider_network__isnull {
6729        local_var_req_builder = local_var_req_builder
6730            .query(&[("provider_network__isnull", &local_var_str.to_string())]);
6731    }
6732    if let Some(ref local_var_str) = provider_network__n {
6733        local_var_req_builder = match "multi" {
6734            "multi" => local_var_req_builder.query(
6735                &local_var_str
6736                    .into_iter()
6737                    .map(|p| ("provider_network__n".to_owned(), p.to_string()))
6738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6739            ),
6740            _ => local_var_req_builder.query(&[(
6741                "provider_network__n",
6742                &local_var_str
6743                    .into_iter()
6744                    .map(|p| p.to_string())
6745                    .collect::<Vec<String>>()
6746                    .join(",")
6747                    .to_string(),
6748            )]),
6749        };
6750    }
6751    if let Some(ref local_var_str) = q {
6752        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6753    }
6754    if let Some(ref local_var_str) = sort {
6755        local_var_req_builder =
6756            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
6757    }
6758    if let Some(ref local_var_str) = status {
6759        local_var_req_builder = match "multi" {
6760            "multi" => local_var_req_builder.query(
6761                &local_var_str
6762                    .into_iter()
6763                    .map(|p| ("status".to_owned(), p.to_string()))
6764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6765            ),
6766            _ => local_var_req_builder.query(&[(
6767                "status",
6768                &local_var_str
6769                    .into_iter()
6770                    .map(|p| p.to_string())
6771                    .collect::<Vec<String>>()
6772                    .join(",")
6773                    .to_string(),
6774            )]),
6775        };
6776    }
6777    if let Some(ref local_var_str) = status__n {
6778        local_var_req_builder = match "multi" {
6779            "multi" => local_var_req_builder.query(
6780                &local_var_str
6781                    .into_iter()
6782                    .map(|p| ("status__n".to_owned(), p.to_string()))
6783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6784            ),
6785            _ => local_var_req_builder.query(&[(
6786                "status__n",
6787                &local_var_str
6788                    .into_iter()
6789                    .map(|p| p.to_string())
6790                    .collect::<Vec<String>>()
6791                    .join(",")
6792                    .to_string(),
6793            )]),
6794        };
6795    }
6796    if let Some(ref local_var_str) = tags {
6797        local_var_req_builder = match "multi" {
6798            "multi" => local_var_req_builder.query(
6799                &local_var_str
6800                    .into_iter()
6801                    .map(|p| ("tags".to_owned(), p.to_string()))
6802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6803            ),
6804            _ => local_var_req_builder.query(&[(
6805                "tags",
6806                &local_var_str
6807                    .into_iter()
6808                    .map(|p| p.to_string())
6809                    .collect::<Vec<String>>()
6810                    .join(",")
6811                    .to_string(),
6812            )]),
6813        };
6814    }
6815    if let Some(ref local_var_str) = tags__isnull {
6816        local_var_req_builder =
6817            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
6818    }
6819    if let Some(ref local_var_str) = tags__n {
6820        local_var_req_builder = match "multi" {
6821            "multi" => local_var_req_builder.query(
6822                &local_var_str
6823                    .into_iter()
6824                    .map(|p| ("tags__n".to_owned(), p.to_string()))
6825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6826            ),
6827            _ => local_var_req_builder.query(&[(
6828                "tags__n",
6829                &local_var_str
6830                    .into_iter()
6831                    .map(|p| p.to_string())
6832                    .collect::<Vec<String>>()
6833                    .join(",")
6834                    .to_string(),
6835            )]),
6836        };
6837    }
6838    if let Some(ref local_var_str) = teams {
6839        local_var_req_builder = match "multi" {
6840            "multi" => local_var_req_builder.query(
6841                &local_var_str
6842                    .into_iter()
6843                    .map(|p| ("teams".to_owned(), p.to_string()))
6844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6845            ),
6846            _ => local_var_req_builder.query(&[(
6847                "teams",
6848                &local_var_str
6849                    .into_iter()
6850                    .map(|p| p.to_string())
6851                    .collect::<Vec<String>>()
6852                    .join(",")
6853                    .to_string(),
6854            )]),
6855        };
6856    }
6857    if let Some(ref local_var_str) = teams__isnull {
6858        local_var_req_builder =
6859            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
6860    }
6861    if let Some(ref local_var_str) = teams__n {
6862        local_var_req_builder = match "multi" {
6863            "multi" => local_var_req_builder.query(
6864                &local_var_str
6865                    .into_iter()
6866                    .map(|p| ("teams__n".to_owned(), p.to_string()))
6867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6868            ),
6869            _ => local_var_req_builder.query(&[(
6870                "teams__n",
6871                &local_var_str
6872                    .into_iter()
6873                    .map(|p| p.to_string())
6874                    .collect::<Vec<String>>()
6875                    .join(",")
6876                    .to_string(),
6877            )]),
6878        };
6879    }
6880    if let Some(ref local_var_str) = tenant {
6881        local_var_req_builder = match "multi" {
6882            "multi" => local_var_req_builder.query(
6883                &local_var_str
6884                    .into_iter()
6885                    .map(|p| ("tenant".to_owned(), p.to_string()))
6886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6887            ),
6888            _ => local_var_req_builder.query(&[(
6889                "tenant",
6890                &local_var_str
6891                    .into_iter()
6892                    .map(|p| p.to_string())
6893                    .collect::<Vec<String>>()
6894                    .join(",")
6895                    .to_string(),
6896            )]),
6897        };
6898    }
6899    if let Some(ref local_var_str) = tenant__isnull {
6900        local_var_req_builder =
6901            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
6902    }
6903    if let Some(ref local_var_str) = tenant__n {
6904        local_var_req_builder = match "multi" {
6905            "multi" => local_var_req_builder.query(
6906                &local_var_str
6907                    .into_iter()
6908                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
6909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6910            ),
6911            _ => local_var_req_builder.query(&[(
6912                "tenant__n",
6913                &local_var_str
6914                    .into_iter()
6915                    .map(|p| p.to_string())
6916                    .collect::<Vec<String>>()
6917                    .join(",")
6918                    .to_string(),
6919            )]),
6920        };
6921    }
6922    if let Some(ref local_var_str) = tenant_group {
6923        local_var_req_builder = match "multi" {
6924            "multi" => local_var_req_builder.query(
6925                &local_var_str
6926                    .into_iter()
6927                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
6928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6929            ),
6930            _ => local_var_req_builder.query(&[(
6931                "tenant_group",
6932                &local_var_str
6933                    .into_iter()
6934                    .map(|p| p.to_string())
6935                    .collect::<Vec<String>>()
6936                    .join(",")
6937                    .to_string(),
6938            )]),
6939        };
6940    }
6941    if let Some(ref local_var_str) = tenant_group__isnull {
6942        local_var_req_builder =
6943            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
6944    }
6945    if let Some(ref local_var_str) = tenant_group__n {
6946        local_var_req_builder = match "multi" {
6947            "multi" => local_var_req_builder.query(
6948                &local_var_str
6949                    .into_iter()
6950                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
6951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6952            ),
6953            _ => local_var_req_builder.query(&[(
6954                "tenant_group__n",
6955                &local_var_str
6956                    .into_iter()
6957                    .map(|p| p.to_string())
6958                    .collect::<Vec<String>>()
6959                    .join(",")
6960                    .to_string(),
6961            )]),
6962        };
6963    }
6964    if let Some(ref local_var_str) = tenant_id {
6965        local_var_req_builder = match "multi" {
6966            "multi" => local_var_req_builder.query(
6967                &local_var_str
6968                    .into_iter()
6969                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
6970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6971            ),
6972            _ => local_var_req_builder.query(&[(
6973                "tenant_id",
6974                &local_var_str
6975                    .into_iter()
6976                    .map(|p| p.to_string())
6977                    .collect::<Vec<String>>()
6978                    .join(",")
6979                    .to_string(),
6980            )]),
6981        };
6982    }
6983    if let Some(ref local_var_str) = tenant_id__isnull {
6984        local_var_req_builder =
6985            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
6986    }
6987    if let Some(ref local_var_str) = tenant_id__n {
6988        local_var_req_builder = match "multi" {
6989            "multi" => local_var_req_builder.query(
6990                &local_var_str
6991                    .into_iter()
6992                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
6993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6994            ),
6995            _ => local_var_req_builder.query(&[(
6996                "tenant_id__n",
6997                &local_var_str
6998                    .into_iter()
6999                    .map(|p| p.to_string())
7000                    .collect::<Vec<String>>()
7001                    .join(",")
7002                    .to_string(),
7003            )]),
7004        };
7005    }
7006    if let Some(ref local_var_str) = depth {
7007        local_var_req_builder =
7008            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7009    }
7010    if let Some(ref local_var_str) = exclude_m2m {
7011        local_var_req_builder =
7012            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7013    }
7014    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7015        local_var_req_builder =
7016            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7017    }
7018    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7019        let local_var_key = local_var_apikey.key.clone();
7020        let local_var_value = match local_var_apikey.prefix {
7021            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7022            None => local_var_key,
7023        };
7024        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7025    };
7026
7027    let local_var_req = local_var_req_builder.build()?;
7028    let local_var_resp = local_var_client.execute(local_var_req).await?;
7029
7030    let local_var_status = local_var_resp.status();
7031    let local_var_content = local_var_resp.text().await?;
7032
7033    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7034        serde_json::from_str(&local_var_content).map_err(Error::from)
7035    } else {
7036        let local_var_entity: Option<CircuitsCircuitsListError> =
7037            serde_json::from_str(&local_var_content).ok();
7038        let local_var_error = ResponseContent {
7039            status: local_var_status,
7040            content: local_var_content,
7041            entity: local_var_entity,
7042        };
7043        Err(Error::ResponseError(local_var_error))
7044    }
7045}
7046
7047/// API methods for returning or creating notes on an object.
7048pub async fn circuits_circuits_notes_create(
7049    configuration: &configuration::Configuration,
7050    id: &str,
7051    note_input_request: crate::models::NoteInputRequest,
7052    format: Option<&str>,
7053) -> Result<crate::models::Note, Error<CircuitsCircuitsNotesCreateError>> {
7054    let local_var_configuration = configuration;
7055
7056    let local_var_client = &local_var_configuration.client;
7057
7058    let local_var_uri_str = format!(
7059        "{}/circuits/circuits/{id}/notes/",
7060        local_var_configuration.base_path,
7061        id = crate::apis::urlencode(id)
7062    );
7063    let mut local_var_req_builder =
7064        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7065
7066    if let Some(ref local_var_str) = format {
7067        local_var_req_builder =
7068            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7069    }
7070    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7071        local_var_req_builder =
7072            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7073    }
7074    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7075        let local_var_key = local_var_apikey.key.clone();
7076        let local_var_value = match local_var_apikey.prefix {
7077            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7078            None => local_var_key,
7079        };
7080        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7081    };
7082    local_var_req_builder = local_var_req_builder.json(&note_input_request);
7083
7084    let local_var_req = local_var_req_builder.build()?;
7085    let local_var_resp = local_var_client.execute(local_var_req).await?;
7086
7087    let local_var_status = local_var_resp.status();
7088    let local_var_content = local_var_resp.text().await?;
7089
7090    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7091        serde_json::from_str(&local_var_content).map_err(Error::from)
7092    } else {
7093        let local_var_entity: Option<CircuitsCircuitsNotesCreateError> =
7094            serde_json::from_str(&local_var_content).ok();
7095        let local_var_error = ResponseContent {
7096            status: local_var_status,
7097            content: local_var_content,
7098            entity: local_var_entity,
7099        };
7100        Err(Error::ResponseError(local_var_error))
7101    }
7102}
7103
7104/// API methods for returning or creating notes on an object.
7105pub async fn circuits_circuits_notes_list(
7106    configuration: &configuration::Configuration,
7107    id: &str,
7108    format: Option<&str>,
7109    limit: Option<i32>,
7110    offset: Option<i32>,
7111    depth: Option<i32>,
7112    exclude_m2m: Option<bool>,
7113) -> Result<crate::models::PaginatedNoteList, Error<CircuitsCircuitsNotesListError>> {
7114    let local_var_configuration = configuration;
7115
7116    let local_var_client = &local_var_configuration.client;
7117
7118    let local_var_uri_str = format!(
7119        "{}/circuits/circuits/{id}/notes/",
7120        local_var_configuration.base_path,
7121        id = crate::apis::urlencode(id)
7122    );
7123    let mut local_var_req_builder =
7124        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7125
7126    if let Some(ref local_var_str) = format {
7127        local_var_req_builder =
7128            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7129    }
7130    if let Some(ref local_var_str) = limit {
7131        local_var_req_builder =
7132            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7133    }
7134    if let Some(ref local_var_str) = offset {
7135        local_var_req_builder =
7136            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7137    }
7138    if let Some(ref local_var_str) = depth {
7139        local_var_req_builder =
7140            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7141    }
7142    if let Some(ref local_var_str) = exclude_m2m {
7143        local_var_req_builder =
7144            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7145    }
7146    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7147        local_var_req_builder =
7148            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7149    }
7150    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7151        let local_var_key = local_var_apikey.key.clone();
7152        let local_var_value = match local_var_apikey.prefix {
7153            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7154            None => local_var_key,
7155        };
7156        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7157    };
7158
7159    let local_var_req = local_var_req_builder.build()?;
7160    let local_var_resp = local_var_client.execute(local_var_req).await?;
7161
7162    let local_var_status = local_var_resp.status();
7163    let local_var_content = local_var_resp.text().await?;
7164
7165    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7166        serde_json::from_str(&local_var_content).map_err(Error::from)
7167    } else {
7168        let local_var_entity: Option<CircuitsCircuitsNotesListError> =
7169            serde_json::from_str(&local_var_content).ok();
7170        let local_var_error = ResponseContent {
7171            status: local_var_status,
7172            content: local_var_content,
7173            entity: local_var_entity,
7174        };
7175        Err(Error::ResponseError(local_var_error))
7176    }
7177}
7178
7179/// Partial update a circuit object.
7180pub async fn circuits_circuits_partial_update(
7181    configuration: &configuration::Configuration,
7182    id: &str,
7183    format: Option<&str>,
7184    patched_circuit_request: Option<crate::models::PatchedCircuitRequest>,
7185) -> Result<crate::models::Circuit, Error<CircuitsCircuitsPartialUpdateError>> {
7186    let local_var_configuration = configuration;
7187
7188    let local_var_client = &local_var_configuration.client;
7189
7190    let local_var_uri_str = format!(
7191        "{}/circuits/circuits/{id}/",
7192        local_var_configuration.base_path,
7193        id = crate::apis::urlencode(id)
7194    );
7195    let mut local_var_req_builder =
7196        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7197
7198    if let Some(ref local_var_str) = format {
7199        local_var_req_builder =
7200            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7201    }
7202    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7203        local_var_req_builder =
7204            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7205    }
7206    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7207        let local_var_key = local_var_apikey.key.clone();
7208        let local_var_value = match local_var_apikey.prefix {
7209            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7210            None => local_var_key,
7211        };
7212        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7213    };
7214    local_var_req_builder = local_var_req_builder.json(&patched_circuit_request);
7215
7216    let local_var_req = local_var_req_builder.build()?;
7217    let local_var_resp = local_var_client.execute(local_var_req).await?;
7218
7219    let local_var_status = local_var_resp.status();
7220    let local_var_content = local_var_resp.text().await?;
7221
7222    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7223        serde_json::from_str(&local_var_content).map_err(Error::from)
7224    } else {
7225        let local_var_entity: Option<CircuitsCircuitsPartialUpdateError> =
7226            serde_json::from_str(&local_var_content).ok();
7227        let local_var_error = ResponseContent {
7228            status: local_var_status,
7229            content: local_var_content,
7230            entity: local_var_entity,
7231        };
7232        Err(Error::ResponseError(local_var_error))
7233    }
7234}
7235
7236/// Retrieve a circuit object.
7237pub async fn circuits_circuits_retrieve(
7238    configuration: &configuration::Configuration,
7239    id: &str,
7240    format: Option<&str>,
7241    depth: Option<i32>,
7242    exclude_m2m: Option<bool>,
7243) -> Result<crate::models::Circuit, Error<CircuitsCircuitsRetrieveError>> {
7244    let local_var_configuration = configuration;
7245
7246    let local_var_client = &local_var_configuration.client;
7247
7248    let local_var_uri_str = format!(
7249        "{}/circuits/circuits/{id}/",
7250        local_var_configuration.base_path,
7251        id = crate::apis::urlencode(id)
7252    );
7253    let mut local_var_req_builder =
7254        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7255
7256    if let Some(ref local_var_str) = format {
7257        local_var_req_builder =
7258            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7259    }
7260    if let Some(ref local_var_str) = depth {
7261        local_var_req_builder =
7262            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7263    }
7264    if let Some(ref local_var_str) = exclude_m2m {
7265        local_var_req_builder =
7266            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7267    }
7268    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7269        local_var_req_builder =
7270            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7271    }
7272    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7273        let local_var_key = local_var_apikey.key.clone();
7274        let local_var_value = match local_var_apikey.prefix {
7275            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7276            None => local_var_key,
7277        };
7278        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7279    };
7280
7281    let local_var_req = local_var_req_builder.build()?;
7282    let local_var_resp = local_var_client.execute(local_var_req).await?;
7283
7284    let local_var_status = local_var_resp.status();
7285    let local_var_content = local_var_resp.text().await?;
7286
7287    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7288        serde_json::from_str(&local_var_content).map_err(Error::from)
7289    } else {
7290        let local_var_entity: Option<CircuitsCircuitsRetrieveError> =
7291            serde_json::from_str(&local_var_content).ok();
7292        let local_var_error = ResponseContent {
7293            status: local_var_status,
7294            content: local_var_content,
7295            entity: local_var_entity,
7296        };
7297        Err(Error::ResponseError(local_var_error))
7298    }
7299}
7300
7301/// Update a circuit object.
7302pub async fn circuits_circuits_update(
7303    configuration: &configuration::Configuration,
7304    id: &str,
7305    circuit_request: crate::models::CircuitRequest,
7306    format: Option<&str>,
7307) -> Result<crate::models::Circuit, Error<CircuitsCircuitsUpdateError>> {
7308    let local_var_configuration = configuration;
7309
7310    let local_var_client = &local_var_configuration.client;
7311
7312    let local_var_uri_str = format!(
7313        "{}/circuits/circuits/{id}/",
7314        local_var_configuration.base_path,
7315        id = crate::apis::urlencode(id)
7316    );
7317    let mut local_var_req_builder =
7318        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7319
7320    if let Some(ref local_var_str) = format {
7321        local_var_req_builder =
7322            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7323    }
7324    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7325        local_var_req_builder =
7326            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7327    }
7328    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7329        let local_var_key = local_var_apikey.key.clone();
7330        let local_var_value = match local_var_apikey.prefix {
7331            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7332            None => local_var_key,
7333        };
7334        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7335    };
7336    local_var_req_builder = local_var_req_builder.json(&circuit_request);
7337
7338    let local_var_req = local_var_req_builder.build()?;
7339    let local_var_resp = local_var_client.execute(local_var_req).await?;
7340
7341    let local_var_status = local_var_resp.status();
7342    let local_var_content = local_var_resp.text().await?;
7343
7344    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7345        serde_json::from_str(&local_var_content).map_err(Error::from)
7346    } else {
7347        let local_var_entity: Option<CircuitsCircuitsUpdateError> =
7348            serde_json::from_str(&local_var_content).ok();
7349        let local_var_error = ResponseContent {
7350            status: local_var_status,
7351            content: local_var_content,
7352            entity: local_var_entity,
7353        };
7354        Err(Error::ResponseError(local_var_error))
7355    }
7356}
7357
7358/// Destroy a list of provider network objects.
7359pub async fn circuits_provider_networks_bulk_destroy(
7360    configuration: &configuration::Configuration,
7361    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
7362    format: Option<&str>,
7363) -> Result<(), Error<CircuitsProviderNetworksBulkDestroyError>> {
7364    let local_var_configuration = configuration;
7365
7366    let local_var_client = &local_var_configuration.client;
7367
7368    let local_var_uri_str = format!(
7369        "{}/circuits/provider-networks/",
7370        local_var_configuration.base_path
7371    );
7372    let mut local_var_req_builder =
7373        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7374
7375    if let Some(ref local_var_str) = format {
7376        local_var_req_builder =
7377            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7378    }
7379    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7380        local_var_req_builder =
7381            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7382    }
7383    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7384        let local_var_key = local_var_apikey.key.clone();
7385        let local_var_value = match local_var_apikey.prefix {
7386            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7387            None => local_var_key,
7388        };
7389        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7390    };
7391    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
7392
7393    let local_var_req = local_var_req_builder.build()?;
7394    let local_var_resp = local_var_client.execute(local_var_req).await?;
7395
7396    let local_var_status = local_var_resp.status();
7397    let local_var_content = local_var_resp.text().await?;
7398
7399    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7400        Ok(())
7401    } else {
7402        let local_var_entity: Option<CircuitsProviderNetworksBulkDestroyError> =
7403            serde_json::from_str(&local_var_content).ok();
7404        let local_var_error = ResponseContent {
7405            status: local_var_status,
7406            content: local_var_content,
7407            entity: local_var_entity,
7408        };
7409        Err(Error::ResponseError(local_var_error))
7410    }
7411}
7412
7413/// Partial update a list of provider network objects.
7414pub async fn circuits_provider_networks_bulk_partial_update(
7415    configuration: &configuration::Configuration,
7416    patched_bulk_writable_provider_network_request: Vec<
7417        crate::models::PatchedBulkWritableProviderNetworkRequest,
7418    >,
7419    format: Option<&str>,
7420) -> Result<
7421    Vec<crate::models::ProviderNetwork>,
7422    Error<CircuitsProviderNetworksBulkPartialUpdateError>,
7423> {
7424    let local_var_configuration = configuration;
7425
7426    let local_var_client = &local_var_configuration.client;
7427
7428    let local_var_uri_str = format!(
7429        "{}/circuits/provider-networks/",
7430        local_var_configuration.base_path
7431    );
7432    let mut local_var_req_builder =
7433        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7434
7435    if let Some(ref local_var_str) = format {
7436        local_var_req_builder =
7437            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7438    }
7439    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7440        local_var_req_builder =
7441            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7442    }
7443    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7444        let local_var_key = local_var_apikey.key.clone();
7445        let local_var_value = match local_var_apikey.prefix {
7446            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7447            None => local_var_key,
7448        };
7449        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7450    };
7451    local_var_req_builder =
7452        local_var_req_builder.json(&patched_bulk_writable_provider_network_request);
7453
7454    let local_var_req = local_var_req_builder.build()?;
7455    let local_var_resp = local_var_client.execute(local_var_req).await?;
7456
7457    let local_var_status = local_var_resp.status();
7458    let local_var_content = local_var_resp.text().await?;
7459
7460    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7461        serde_json::from_str(&local_var_content).map_err(Error::from)
7462    } else {
7463        let local_var_entity: Option<CircuitsProviderNetworksBulkPartialUpdateError> =
7464            serde_json::from_str(&local_var_content).ok();
7465        let local_var_error = ResponseContent {
7466            status: local_var_status,
7467            content: local_var_content,
7468            entity: local_var_entity,
7469        };
7470        Err(Error::ResponseError(local_var_error))
7471    }
7472}
7473
7474/// Update a list of provider network objects.
7475pub async fn circuits_provider_networks_bulk_update(
7476    configuration: &configuration::Configuration,
7477    bulk_writable_provider_network_request: Vec<crate::models::BulkWritableProviderNetworkRequest>,
7478    format: Option<&str>,
7479) -> Result<Vec<crate::models::ProviderNetwork>, Error<CircuitsProviderNetworksBulkUpdateError>> {
7480    let local_var_configuration = configuration;
7481
7482    let local_var_client = &local_var_configuration.client;
7483
7484    let local_var_uri_str = format!(
7485        "{}/circuits/provider-networks/",
7486        local_var_configuration.base_path
7487    );
7488    let mut local_var_req_builder =
7489        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7490
7491    if let Some(ref local_var_str) = format {
7492        local_var_req_builder =
7493            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7494    }
7495    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7496        local_var_req_builder =
7497            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7498    }
7499    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7500        let local_var_key = local_var_apikey.key.clone();
7501        let local_var_value = match local_var_apikey.prefix {
7502            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7503            None => local_var_key,
7504        };
7505        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7506    };
7507    local_var_req_builder = local_var_req_builder.json(&bulk_writable_provider_network_request);
7508
7509    let local_var_req = local_var_req_builder.build()?;
7510    let local_var_resp = local_var_client.execute(local_var_req).await?;
7511
7512    let local_var_status = local_var_resp.status();
7513    let local_var_content = local_var_resp.text().await?;
7514
7515    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7516        serde_json::from_str(&local_var_content).map_err(Error::from)
7517    } else {
7518        let local_var_entity: Option<CircuitsProviderNetworksBulkUpdateError> =
7519            serde_json::from_str(&local_var_content).ok();
7520        let local_var_error = ResponseContent {
7521            status: local_var_status,
7522            content: local_var_content,
7523            entity: local_var_entity,
7524        };
7525        Err(Error::ResponseError(local_var_error))
7526    }
7527}
7528
7529/// Create one or more provider network objects.
7530pub async fn circuits_provider_networks_create(
7531    configuration: &configuration::Configuration,
7532    provider_network_request: crate::models::ProviderNetworkRequest,
7533    format: Option<&str>,
7534) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksCreateError>> {
7535    let local_var_configuration = configuration;
7536
7537    let local_var_client = &local_var_configuration.client;
7538
7539    let local_var_uri_str = format!(
7540        "{}/circuits/provider-networks/",
7541        local_var_configuration.base_path
7542    );
7543    let mut local_var_req_builder =
7544        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7545
7546    if let Some(ref local_var_str) = format {
7547        local_var_req_builder =
7548            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7549    }
7550    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7551        local_var_req_builder =
7552            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7553    }
7554    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7555        let local_var_key = local_var_apikey.key.clone();
7556        let local_var_value = match local_var_apikey.prefix {
7557            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7558            None => local_var_key,
7559        };
7560        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7561    };
7562    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
7563
7564    let local_var_req = local_var_req_builder.build()?;
7565    let local_var_resp = local_var_client.execute(local_var_req).await?;
7566
7567    let local_var_status = local_var_resp.status();
7568    let local_var_content = local_var_resp.text().await?;
7569
7570    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7571        serde_json::from_str(&local_var_content).map_err(Error::from)
7572    } else {
7573        let local_var_entity: Option<CircuitsProviderNetworksCreateError> =
7574            serde_json::from_str(&local_var_content).ok();
7575        let local_var_error = ResponseContent {
7576            status: local_var_status,
7577            content: local_var_content,
7578            entity: local_var_entity,
7579        };
7580        Err(Error::ResponseError(local_var_error))
7581    }
7582}
7583
7584/// Destroy a provider network object.
7585pub async fn circuits_provider_networks_destroy(
7586    configuration: &configuration::Configuration,
7587    id: &str,
7588    format: Option<&str>,
7589) -> Result<(), Error<CircuitsProviderNetworksDestroyError>> {
7590    let local_var_configuration = configuration;
7591
7592    let local_var_client = &local_var_configuration.client;
7593
7594    let local_var_uri_str = format!(
7595        "{}/circuits/provider-networks/{id}/",
7596        local_var_configuration.base_path,
7597        id = crate::apis::urlencode(id)
7598    );
7599    let mut local_var_req_builder =
7600        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7601
7602    if let Some(ref local_var_str) = format {
7603        local_var_req_builder =
7604            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7605    }
7606    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7607        local_var_req_builder =
7608            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7609    }
7610    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7611        let local_var_key = local_var_apikey.key.clone();
7612        let local_var_value = match local_var_apikey.prefix {
7613            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7614            None => local_var_key,
7615        };
7616        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7617    };
7618
7619    let local_var_req = local_var_req_builder.build()?;
7620    let local_var_resp = local_var_client.execute(local_var_req).await?;
7621
7622    let local_var_status = local_var_resp.status();
7623    let local_var_content = local_var_resp.text().await?;
7624
7625    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7626        Ok(())
7627    } else {
7628        let local_var_entity: Option<CircuitsProviderNetworksDestroyError> =
7629            serde_json::from_str(&local_var_content).ok();
7630        let local_var_error = ResponseContent {
7631            status: local_var_status,
7632            content: local_var_content,
7633            entity: local_var_entity,
7634        };
7635        Err(Error::ResponseError(local_var_error))
7636    }
7637}
7638
7639/// Retrieve a list of provider network objects.
7640pub async fn circuits_provider_networks_list(
7641    configuration: &configuration::Configuration,
7642    circuit_terminations: Option<Vec<uuid::Uuid>>,
7643    circuit_terminations__isnull: Option<bool>,
7644    circuit_terminations__n: Option<Vec<uuid::Uuid>>,
7645    comments: Option<Vec<String>>,
7646    comments__ic: Option<Vec<String>>,
7647    comments__ie: Option<Vec<String>>,
7648    comments__iew: Option<Vec<String>>,
7649    comments__ire: Option<Vec<String>>,
7650    comments__isw: Option<Vec<String>>,
7651    comments__n: Option<Vec<String>>,
7652    comments__nic: Option<Vec<String>>,
7653    comments__nie: Option<Vec<String>>,
7654    comments__niew: Option<Vec<String>>,
7655    comments__nire: Option<Vec<String>>,
7656    comments__nisw: Option<Vec<String>>,
7657    comments__nre: Option<Vec<String>>,
7658    comments__re: Option<Vec<String>>,
7659    contacts: Option<Vec<String>>,
7660    contacts__isnull: Option<bool>,
7661    contacts__n: Option<Vec<String>>,
7662    created: Option<Vec<String>>,
7663    created__gt: Option<Vec<String>>,
7664    created__gte: Option<Vec<String>>,
7665    created__isnull: Option<bool>,
7666    created__lt: Option<Vec<String>>,
7667    created__lte: Option<Vec<String>>,
7668    created__n: Option<Vec<String>>,
7669    description: Option<Vec<String>>,
7670    description__ic: Option<Vec<String>>,
7671    description__ie: Option<Vec<String>>,
7672    description__iew: Option<Vec<String>>,
7673    description__ire: Option<Vec<String>>,
7674    description__isw: Option<Vec<String>>,
7675    description__n: Option<Vec<String>>,
7676    description__nic: Option<Vec<String>>,
7677    description__nie: Option<Vec<String>>,
7678    description__niew: Option<Vec<String>>,
7679    description__nire: Option<Vec<String>>,
7680    description__nisw: Option<Vec<String>>,
7681    description__nre: Option<Vec<String>>,
7682    description__re: Option<Vec<String>>,
7683    dynamic_groups: Option<Vec<String>>,
7684    dynamic_groups__n: Option<Vec<String>>,
7685    format: Option<&str>,
7686    has_circuit_terminations: Option<bool>,
7687    id: Option<Vec<uuid::Uuid>>,
7688    id__n: Option<Vec<uuid::Uuid>>,
7689    last_updated: Option<Vec<String>>,
7690    last_updated__gt: Option<Vec<String>>,
7691    last_updated__gte: Option<Vec<String>>,
7692    last_updated__isnull: Option<bool>,
7693    last_updated__lt: Option<Vec<String>>,
7694    last_updated__lte: Option<Vec<String>>,
7695    last_updated__n: Option<Vec<String>>,
7696    limit: Option<i32>,
7697    name: Option<Vec<String>>,
7698    name__ic: Option<Vec<String>>,
7699    name__ie: Option<Vec<String>>,
7700    name__iew: Option<Vec<String>>,
7701    name__ire: Option<Vec<String>>,
7702    name__isw: Option<Vec<String>>,
7703    name__n: Option<Vec<String>>,
7704    name__nic: Option<Vec<String>>,
7705    name__nie: Option<Vec<String>>,
7706    name__niew: Option<Vec<String>>,
7707    name__nire: Option<Vec<String>>,
7708    name__nisw: Option<Vec<String>>,
7709    name__nre: Option<Vec<String>>,
7710    name__re: Option<Vec<String>>,
7711    offset: Option<i32>,
7712    provider: Option<Vec<String>>,
7713    provider__n: Option<Vec<String>>,
7714    q: Option<&str>,
7715    sort: Option<&str>,
7716    tags: Option<Vec<String>>,
7717    tags__isnull: Option<bool>,
7718    tags__n: Option<Vec<String>>,
7719    teams: Option<Vec<String>>,
7720    teams__isnull: Option<bool>,
7721    teams__n: Option<Vec<String>>,
7722    depth: Option<i32>,
7723    exclude_m2m: Option<bool>,
7724) -> Result<crate::models::PaginatedProviderNetworkList, Error<CircuitsProviderNetworksListError>> {
7725    let local_var_configuration = configuration;
7726
7727    let local_var_client = &local_var_configuration.client;
7728
7729    let local_var_uri_str = format!(
7730        "{}/circuits/provider-networks/",
7731        local_var_configuration.base_path
7732    );
7733    let mut local_var_req_builder =
7734        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7735
7736    if let Some(ref local_var_str) = circuit_terminations {
7737        local_var_req_builder = match "multi" {
7738            "multi" => local_var_req_builder.query(
7739                &local_var_str
7740                    .into_iter()
7741                    .map(|p| ("circuit_terminations".to_owned(), p.to_string()))
7742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7743            ),
7744            _ => local_var_req_builder.query(&[(
7745                "circuit_terminations",
7746                &local_var_str
7747                    .into_iter()
7748                    .map(|p| p.to_string())
7749                    .collect::<Vec<String>>()
7750                    .join(",")
7751                    .to_string(),
7752            )]),
7753        };
7754    }
7755    if let Some(ref local_var_str) = circuit_terminations__isnull {
7756        local_var_req_builder = local_var_req_builder
7757            .query(&[("circuit_terminations__isnull", &local_var_str.to_string())]);
7758    }
7759    if let Some(ref local_var_str) = circuit_terminations__n {
7760        local_var_req_builder = match "multi" {
7761            "multi" => local_var_req_builder.query(
7762                &local_var_str
7763                    .into_iter()
7764                    .map(|p| ("circuit_terminations__n".to_owned(), p.to_string()))
7765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7766            ),
7767            _ => local_var_req_builder.query(&[(
7768                "circuit_terminations__n",
7769                &local_var_str
7770                    .into_iter()
7771                    .map(|p| p.to_string())
7772                    .collect::<Vec<String>>()
7773                    .join(",")
7774                    .to_string(),
7775            )]),
7776        };
7777    }
7778    if let Some(ref local_var_str) = comments {
7779        local_var_req_builder = match "multi" {
7780            "multi" => local_var_req_builder.query(
7781                &local_var_str
7782                    .into_iter()
7783                    .map(|p| ("comments".to_owned(), p.to_string()))
7784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7785            ),
7786            _ => local_var_req_builder.query(&[(
7787                "comments",
7788                &local_var_str
7789                    .into_iter()
7790                    .map(|p| p.to_string())
7791                    .collect::<Vec<String>>()
7792                    .join(",")
7793                    .to_string(),
7794            )]),
7795        };
7796    }
7797    if let Some(ref local_var_str) = comments__ic {
7798        local_var_req_builder = match "multi" {
7799            "multi" => local_var_req_builder.query(
7800                &local_var_str
7801                    .into_iter()
7802                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
7803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7804            ),
7805            _ => local_var_req_builder.query(&[(
7806                "comments__ic",
7807                &local_var_str
7808                    .into_iter()
7809                    .map(|p| p.to_string())
7810                    .collect::<Vec<String>>()
7811                    .join(",")
7812                    .to_string(),
7813            )]),
7814        };
7815    }
7816    if let Some(ref local_var_str) = comments__ie {
7817        local_var_req_builder = match "multi" {
7818            "multi" => local_var_req_builder.query(
7819                &local_var_str
7820                    .into_iter()
7821                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
7822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7823            ),
7824            _ => local_var_req_builder.query(&[(
7825                "comments__ie",
7826                &local_var_str
7827                    .into_iter()
7828                    .map(|p| p.to_string())
7829                    .collect::<Vec<String>>()
7830                    .join(",")
7831                    .to_string(),
7832            )]),
7833        };
7834    }
7835    if let Some(ref local_var_str) = comments__iew {
7836        local_var_req_builder = match "multi" {
7837            "multi" => local_var_req_builder.query(
7838                &local_var_str
7839                    .into_iter()
7840                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
7841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7842            ),
7843            _ => local_var_req_builder.query(&[(
7844                "comments__iew",
7845                &local_var_str
7846                    .into_iter()
7847                    .map(|p| p.to_string())
7848                    .collect::<Vec<String>>()
7849                    .join(",")
7850                    .to_string(),
7851            )]),
7852        };
7853    }
7854    if let Some(ref local_var_str) = comments__ire {
7855        local_var_req_builder = match "multi" {
7856            "multi" => local_var_req_builder.query(
7857                &local_var_str
7858                    .into_iter()
7859                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
7860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7861            ),
7862            _ => local_var_req_builder.query(&[(
7863                "comments__ire",
7864                &local_var_str
7865                    .into_iter()
7866                    .map(|p| p.to_string())
7867                    .collect::<Vec<String>>()
7868                    .join(",")
7869                    .to_string(),
7870            )]),
7871        };
7872    }
7873    if let Some(ref local_var_str) = comments__isw {
7874        local_var_req_builder = match "multi" {
7875            "multi" => local_var_req_builder.query(
7876                &local_var_str
7877                    .into_iter()
7878                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
7879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7880            ),
7881            _ => local_var_req_builder.query(&[(
7882                "comments__isw",
7883                &local_var_str
7884                    .into_iter()
7885                    .map(|p| p.to_string())
7886                    .collect::<Vec<String>>()
7887                    .join(",")
7888                    .to_string(),
7889            )]),
7890        };
7891    }
7892    if let Some(ref local_var_str) = comments__n {
7893        local_var_req_builder = match "multi" {
7894            "multi" => local_var_req_builder.query(
7895                &local_var_str
7896                    .into_iter()
7897                    .map(|p| ("comments__n".to_owned(), p.to_string()))
7898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7899            ),
7900            _ => local_var_req_builder.query(&[(
7901                "comments__n",
7902                &local_var_str
7903                    .into_iter()
7904                    .map(|p| p.to_string())
7905                    .collect::<Vec<String>>()
7906                    .join(",")
7907                    .to_string(),
7908            )]),
7909        };
7910    }
7911    if let Some(ref local_var_str) = comments__nic {
7912        local_var_req_builder = match "multi" {
7913            "multi" => local_var_req_builder.query(
7914                &local_var_str
7915                    .into_iter()
7916                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
7917                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7918            ),
7919            _ => local_var_req_builder.query(&[(
7920                "comments__nic",
7921                &local_var_str
7922                    .into_iter()
7923                    .map(|p| p.to_string())
7924                    .collect::<Vec<String>>()
7925                    .join(",")
7926                    .to_string(),
7927            )]),
7928        };
7929    }
7930    if let Some(ref local_var_str) = comments__nie {
7931        local_var_req_builder = match "multi" {
7932            "multi" => local_var_req_builder.query(
7933                &local_var_str
7934                    .into_iter()
7935                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
7936                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7937            ),
7938            _ => local_var_req_builder.query(&[(
7939                "comments__nie",
7940                &local_var_str
7941                    .into_iter()
7942                    .map(|p| p.to_string())
7943                    .collect::<Vec<String>>()
7944                    .join(",")
7945                    .to_string(),
7946            )]),
7947        };
7948    }
7949    if let Some(ref local_var_str) = comments__niew {
7950        local_var_req_builder = match "multi" {
7951            "multi" => local_var_req_builder.query(
7952                &local_var_str
7953                    .into_iter()
7954                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
7955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7956            ),
7957            _ => local_var_req_builder.query(&[(
7958                "comments__niew",
7959                &local_var_str
7960                    .into_iter()
7961                    .map(|p| p.to_string())
7962                    .collect::<Vec<String>>()
7963                    .join(",")
7964                    .to_string(),
7965            )]),
7966        };
7967    }
7968    if let Some(ref local_var_str) = comments__nire {
7969        local_var_req_builder = match "multi" {
7970            "multi" => local_var_req_builder.query(
7971                &local_var_str
7972                    .into_iter()
7973                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
7974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7975            ),
7976            _ => local_var_req_builder.query(&[(
7977                "comments__nire",
7978                &local_var_str
7979                    .into_iter()
7980                    .map(|p| p.to_string())
7981                    .collect::<Vec<String>>()
7982                    .join(",")
7983                    .to_string(),
7984            )]),
7985        };
7986    }
7987    if let Some(ref local_var_str) = comments__nisw {
7988        local_var_req_builder = match "multi" {
7989            "multi" => local_var_req_builder.query(
7990                &local_var_str
7991                    .into_iter()
7992                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
7993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7994            ),
7995            _ => local_var_req_builder.query(&[(
7996                "comments__nisw",
7997                &local_var_str
7998                    .into_iter()
7999                    .map(|p| p.to_string())
8000                    .collect::<Vec<String>>()
8001                    .join(",")
8002                    .to_string(),
8003            )]),
8004        };
8005    }
8006    if let Some(ref local_var_str) = comments__nre {
8007        local_var_req_builder = match "multi" {
8008            "multi" => local_var_req_builder.query(
8009                &local_var_str
8010                    .into_iter()
8011                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
8012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8013            ),
8014            _ => local_var_req_builder.query(&[(
8015                "comments__nre",
8016                &local_var_str
8017                    .into_iter()
8018                    .map(|p| p.to_string())
8019                    .collect::<Vec<String>>()
8020                    .join(",")
8021                    .to_string(),
8022            )]),
8023        };
8024    }
8025    if let Some(ref local_var_str) = comments__re {
8026        local_var_req_builder = match "multi" {
8027            "multi" => local_var_req_builder.query(
8028                &local_var_str
8029                    .into_iter()
8030                    .map(|p| ("comments__re".to_owned(), p.to_string()))
8031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8032            ),
8033            _ => local_var_req_builder.query(&[(
8034                "comments__re",
8035                &local_var_str
8036                    .into_iter()
8037                    .map(|p| p.to_string())
8038                    .collect::<Vec<String>>()
8039                    .join(",")
8040                    .to_string(),
8041            )]),
8042        };
8043    }
8044    if let Some(ref local_var_str) = contacts {
8045        local_var_req_builder = match "multi" {
8046            "multi" => local_var_req_builder.query(
8047                &local_var_str
8048                    .into_iter()
8049                    .map(|p| ("contacts".to_owned(), p.to_string()))
8050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8051            ),
8052            _ => local_var_req_builder.query(&[(
8053                "contacts",
8054                &local_var_str
8055                    .into_iter()
8056                    .map(|p| p.to_string())
8057                    .collect::<Vec<String>>()
8058                    .join(",")
8059                    .to_string(),
8060            )]),
8061        };
8062    }
8063    if let Some(ref local_var_str) = contacts__isnull {
8064        local_var_req_builder =
8065            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
8066    }
8067    if let Some(ref local_var_str) = contacts__n {
8068        local_var_req_builder = match "multi" {
8069            "multi" => local_var_req_builder.query(
8070                &local_var_str
8071                    .into_iter()
8072                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
8073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8074            ),
8075            _ => local_var_req_builder.query(&[(
8076                "contacts__n",
8077                &local_var_str
8078                    .into_iter()
8079                    .map(|p| p.to_string())
8080                    .collect::<Vec<String>>()
8081                    .join(",")
8082                    .to_string(),
8083            )]),
8084        };
8085    }
8086    if let Some(ref local_var_str) = created {
8087        local_var_req_builder = match "multi" {
8088            "multi" => local_var_req_builder.query(
8089                &local_var_str
8090                    .into_iter()
8091                    .map(|p| ("created".to_owned(), p.to_string()))
8092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8093            ),
8094            _ => local_var_req_builder.query(&[(
8095                "created",
8096                &local_var_str
8097                    .into_iter()
8098                    .map(|p| p.to_string())
8099                    .collect::<Vec<String>>()
8100                    .join(",")
8101                    .to_string(),
8102            )]),
8103        };
8104    }
8105    if let Some(ref local_var_str) = created__gt {
8106        local_var_req_builder = match "multi" {
8107            "multi" => local_var_req_builder.query(
8108                &local_var_str
8109                    .into_iter()
8110                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8112            ),
8113            _ => local_var_req_builder.query(&[(
8114                "created__gt",
8115                &local_var_str
8116                    .into_iter()
8117                    .map(|p| p.to_string())
8118                    .collect::<Vec<String>>()
8119                    .join(",")
8120                    .to_string(),
8121            )]),
8122        };
8123    }
8124    if let Some(ref local_var_str) = created__gte {
8125        local_var_req_builder = match "multi" {
8126            "multi" => local_var_req_builder.query(
8127                &local_var_str
8128                    .into_iter()
8129                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8131            ),
8132            _ => local_var_req_builder.query(&[(
8133                "created__gte",
8134                &local_var_str
8135                    .into_iter()
8136                    .map(|p| p.to_string())
8137                    .collect::<Vec<String>>()
8138                    .join(",")
8139                    .to_string(),
8140            )]),
8141        };
8142    }
8143    if let Some(ref local_var_str) = created__isnull {
8144        local_var_req_builder =
8145            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
8146    }
8147    if let Some(ref local_var_str) = created__lt {
8148        local_var_req_builder = match "multi" {
8149            "multi" => local_var_req_builder.query(
8150                &local_var_str
8151                    .into_iter()
8152                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8154            ),
8155            _ => local_var_req_builder.query(&[(
8156                "created__lt",
8157                &local_var_str
8158                    .into_iter()
8159                    .map(|p| p.to_string())
8160                    .collect::<Vec<String>>()
8161                    .join(",")
8162                    .to_string(),
8163            )]),
8164        };
8165    }
8166    if let Some(ref local_var_str) = created__lte {
8167        local_var_req_builder = match "multi" {
8168            "multi" => local_var_req_builder.query(
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8173            ),
8174            _ => local_var_req_builder.query(&[(
8175                "created__lte",
8176                &local_var_str
8177                    .into_iter()
8178                    .map(|p| p.to_string())
8179                    .collect::<Vec<String>>()
8180                    .join(",")
8181                    .to_string(),
8182            )]),
8183        };
8184    }
8185    if let Some(ref local_var_str) = created__n {
8186        local_var_req_builder = match "multi" {
8187            "multi" => local_var_req_builder.query(
8188                &local_var_str
8189                    .into_iter()
8190                    .map(|p| ("created__n".to_owned(), p.to_string()))
8191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8192            ),
8193            _ => local_var_req_builder.query(&[(
8194                "created__n",
8195                &local_var_str
8196                    .into_iter()
8197                    .map(|p| p.to_string())
8198                    .collect::<Vec<String>>()
8199                    .join(",")
8200                    .to_string(),
8201            )]),
8202        };
8203    }
8204    if let Some(ref local_var_str) = description {
8205        local_var_req_builder = match "multi" {
8206            "multi" => local_var_req_builder.query(
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| ("description".to_owned(), p.to_string()))
8210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8211            ),
8212            _ => local_var_req_builder.query(&[(
8213                "description",
8214                &local_var_str
8215                    .into_iter()
8216                    .map(|p| p.to_string())
8217                    .collect::<Vec<String>>()
8218                    .join(",")
8219                    .to_string(),
8220            )]),
8221        };
8222    }
8223    if let Some(ref local_var_str) = description__ic {
8224        local_var_req_builder = match "multi" {
8225            "multi" => local_var_req_builder.query(
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8230            ),
8231            _ => local_var_req_builder.query(&[(
8232                "description__ic",
8233                &local_var_str
8234                    .into_iter()
8235                    .map(|p| p.to_string())
8236                    .collect::<Vec<String>>()
8237                    .join(",")
8238                    .to_string(),
8239            )]),
8240        };
8241    }
8242    if let Some(ref local_var_str) = description__ie {
8243        local_var_req_builder = match "multi" {
8244            "multi" => local_var_req_builder.query(
8245                &local_var_str
8246                    .into_iter()
8247                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8249            ),
8250            _ => local_var_req_builder.query(&[(
8251                "description__ie",
8252                &local_var_str
8253                    .into_iter()
8254                    .map(|p| p.to_string())
8255                    .collect::<Vec<String>>()
8256                    .join(",")
8257                    .to_string(),
8258            )]),
8259        };
8260    }
8261    if let Some(ref local_var_str) = description__iew {
8262        local_var_req_builder = match "multi" {
8263            "multi" => local_var_req_builder.query(
8264                &local_var_str
8265                    .into_iter()
8266                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8268            ),
8269            _ => local_var_req_builder.query(&[(
8270                "description__iew",
8271                &local_var_str
8272                    .into_iter()
8273                    .map(|p| p.to_string())
8274                    .collect::<Vec<String>>()
8275                    .join(",")
8276                    .to_string(),
8277            )]),
8278        };
8279    }
8280    if let Some(ref local_var_str) = description__ire {
8281        local_var_req_builder = match "multi" {
8282            "multi" => local_var_req_builder.query(
8283                &local_var_str
8284                    .into_iter()
8285                    .map(|p| ("description__ire".to_owned(), p.to_string()))
8286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8287            ),
8288            _ => local_var_req_builder.query(&[(
8289                "description__ire",
8290                &local_var_str
8291                    .into_iter()
8292                    .map(|p| p.to_string())
8293                    .collect::<Vec<String>>()
8294                    .join(",")
8295                    .to_string(),
8296            )]),
8297        };
8298    }
8299    if let Some(ref local_var_str) = description__isw {
8300        local_var_req_builder = match "multi" {
8301            "multi" => local_var_req_builder.query(
8302                &local_var_str
8303                    .into_iter()
8304                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8306            ),
8307            _ => local_var_req_builder.query(&[(
8308                "description__isw",
8309                &local_var_str
8310                    .into_iter()
8311                    .map(|p| p.to_string())
8312                    .collect::<Vec<String>>()
8313                    .join(",")
8314                    .to_string(),
8315            )]),
8316        };
8317    }
8318    if let Some(ref local_var_str) = description__n {
8319        local_var_req_builder = match "multi" {
8320            "multi" => local_var_req_builder.query(
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| ("description__n".to_owned(), p.to_string()))
8324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8325            ),
8326            _ => local_var_req_builder.query(&[(
8327                "description__n",
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| p.to_string())
8331                    .collect::<Vec<String>>()
8332                    .join(",")
8333                    .to_string(),
8334            )]),
8335        };
8336    }
8337    if let Some(ref local_var_str) = description__nic {
8338        local_var_req_builder = match "multi" {
8339            "multi" => local_var_req_builder.query(
8340                &local_var_str
8341                    .into_iter()
8342                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8344            ),
8345            _ => local_var_req_builder.query(&[(
8346                "description__nic",
8347                &local_var_str
8348                    .into_iter()
8349                    .map(|p| p.to_string())
8350                    .collect::<Vec<String>>()
8351                    .join(",")
8352                    .to_string(),
8353            )]),
8354        };
8355    }
8356    if let Some(ref local_var_str) = description__nie {
8357        local_var_req_builder = match "multi" {
8358            "multi" => local_var_req_builder.query(
8359                &local_var_str
8360                    .into_iter()
8361                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8363            ),
8364            _ => local_var_req_builder.query(&[(
8365                "description__nie",
8366                &local_var_str
8367                    .into_iter()
8368                    .map(|p| p.to_string())
8369                    .collect::<Vec<String>>()
8370                    .join(",")
8371                    .to_string(),
8372            )]),
8373        };
8374    }
8375    if let Some(ref local_var_str) = description__niew {
8376        local_var_req_builder = match "multi" {
8377            "multi" => local_var_req_builder.query(
8378                &local_var_str
8379                    .into_iter()
8380                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8382            ),
8383            _ => local_var_req_builder.query(&[(
8384                "description__niew",
8385                &local_var_str
8386                    .into_iter()
8387                    .map(|p| p.to_string())
8388                    .collect::<Vec<String>>()
8389                    .join(",")
8390                    .to_string(),
8391            )]),
8392        };
8393    }
8394    if let Some(ref local_var_str) = description__nire {
8395        local_var_req_builder = match "multi" {
8396            "multi" => local_var_req_builder.query(
8397                &local_var_str
8398                    .into_iter()
8399                    .map(|p| ("description__nire".to_owned(), p.to_string()))
8400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8401            ),
8402            _ => local_var_req_builder.query(&[(
8403                "description__nire",
8404                &local_var_str
8405                    .into_iter()
8406                    .map(|p| p.to_string())
8407                    .collect::<Vec<String>>()
8408                    .join(",")
8409                    .to_string(),
8410            )]),
8411        };
8412    }
8413    if let Some(ref local_var_str) = description__nisw {
8414        local_var_req_builder = match "multi" {
8415            "multi" => local_var_req_builder.query(
8416                &local_var_str
8417                    .into_iter()
8418                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8420            ),
8421            _ => local_var_req_builder.query(&[(
8422                "description__nisw",
8423                &local_var_str
8424                    .into_iter()
8425                    .map(|p| p.to_string())
8426                    .collect::<Vec<String>>()
8427                    .join(",")
8428                    .to_string(),
8429            )]),
8430        };
8431    }
8432    if let Some(ref local_var_str) = description__nre {
8433        local_var_req_builder = match "multi" {
8434            "multi" => local_var_req_builder.query(
8435                &local_var_str
8436                    .into_iter()
8437                    .map(|p| ("description__nre".to_owned(), p.to_string()))
8438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8439            ),
8440            _ => local_var_req_builder.query(&[(
8441                "description__nre",
8442                &local_var_str
8443                    .into_iter()
8444                    .map(|p| p.to_string())
8445                    .collect::<Vec<String>>()
8446                    .join(",")
8447                    .to_string(),
8448            )]),
8449        };
8450    }
8451    if let Some(ref local_var_str) = description__re {
8452        local_var_req_builder = match "multi" {
8453            "multi" => local_var_req_builder.query(
8454                &local_var_str
8455                    .into_iter()
8456                    .map(|p| ("description__re".to_owned(), p.to_string()))
8457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8458            ),
8459            _ => local_var_req_builder.query(&[(
8460                "description__re",
8461                &local_var_str
8462                    .into_iter()
8463                    .map(|p| p.to_string())
8464                    .collect::<Vec<String>>()
8465                    .join(",")
8466                    .to_string(),
8467            )]),
8468        };
8469    }
8470    if let Some(ref local_var_str) = dynamic_groups {
8471        local_var_req_builder = match "multi" {
8472            "multi" => local_var_req_builder.query(
8473                &local_var_str
8474                    .into_iter()
8475                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
8476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8477            ),
8478            _ => local_var_req_builder.query(&[(
8479                "dynamic_groups",
8480                &local_var_str
8481                    .into_iter()
8482                    .map(|p| p.to_string())
8483                    .collect::<Vec<String>>()
8484                    .join(",")
8485                    .to_string(),
8486            )]),
8487        };
8488    }
8489    if let Some(ref local_var_str) = dynamic_groups__n {
8490        local_var_req_builder = match "multi" {
8491            "multi" => local_var_req_builder.query(
8492                &local_var_str
8493                    .into_iter()
8494                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
8495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8496            ),
8497            _ => local_var_req_builder.query(&[(
8498                "dynamic_groups__n",
8499                &local_var_str
8500                    .into_iter()
8501                    .map(|p| p.to_string())
8502                    .collect::<Vec<String>>()
8503                    .join(",")
8504                    .to_string(),
8505            )]),
8506        };
8507    }
8508    if let Some(ref local_var_str) = format {
8509        local_var_req_builder =
8510            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8511    }
8512    if let Some(ref local_var_str) = has_circuit_terminations {
8513        local_var_req_builder = local_var_req_builder
8514            .query(&[("has_circuit_terminations", &local_var_str.to_string())]);
8515    }
8516    if let Some(ref local_var_str) = id {
8517        local_var_req_builder = match "multi" {
8518            "multi" => local_var_req_builder.query(
8519                &local_var_str
8520                    .into_iter()
8521                    .map(|p| ("id".to_owned(), p.to_string()))
8522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8523            ),
8524            _ => local_var_req_builder.query(&[(
8525                "id",
8526                &local_var_str
8527                    .into_iter()
8528                    .map(|p| p.to_string())
8529                    .collect::<Vec<String>>()
8530                    .join(",")
8531                    .to_string(),
8532            )]),
8533        };
8534    }
8535    if let Some(ref local_var_str) = id__n {
8536        local_var_req_builder = match "multi" {
8537            "multi" => local_var_req_builder.query(
8538                &local_var_str
8539                    .into_iter()
8540                    .map(|p| ("id__n".to_owned(), p.to_string()))
8541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8542            ),
8543            _ => local_var_req_builder.query(&[(
8544                "id__n",
8545                &local_var_str
8546                    .into_iter()
8547                    .map(|p| p.to_string())
8548                    .collect::<Vec<String>>()
8549                    .join(",")
8550                    .to_string(),
8551            )]),
8552        };
8553    }
8554    if let Some(ref local_var_str) = last_updated {
8555        local_var_req_builder = match "multi" {
8556            "multi" => local_var_req_builder.query(
8557                &local_var_str
8558                    .into_iter()
8559                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8561            ),
8562            _ => local_var_req_builder.query(&[(
8563                "last_updated",
8564                &local_var_str
8565                    .into_iter()
8566                    .map(|p| p.to_string())
8567                    .collect::<Vec<String>>()
8568                    .join(",")
8569                    .to_string(),
8570            )]),
8571        };
8572    }
8573    if let Some(ref local_var_str) = last_updated__gt {
8574        local_var_req_builder = match "multi" {
8575            "multi" => local_var_req_builder.query(
8576                &local_var_str
8577                    .into_iter()
8578                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8580            ),
8581            _ => local_var_req_builder.query(&[(
8582                "last_updated__gt",
8583                &local_var_str
8584                    .into_iter()
8585                    .map(|p| p.to_string())
8586                    .collect::<Vec<String>>()
8587                    .join(",")
8588                    .to_string(),
8589            )]),
8590        };
8591    }
8592    if let Some(ref local_var_str) = last_updated__gte {
8593        local_var_req_builder = match "multi" {
8594            "multi" => local_var_req_builder.query(
8595                &local_var_str
8596                    .into_iter()
8597                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8599            ),
8600            _ => local_var_req_builder.query(&[(
8601                "last_updated__gte",
8602                &local_var_str
8603                    .into_iter()
8604                    .map(|p| p.to_string())
8605                    .collect::<Vec<String>>()
8606                    .join(",")
8607                    .to_string(),
8608            )]),
8609        };
8610    }
8611    if let Some(ref local_var_str) = last_updated__isnull {
8612        local_var_req_builder =
8613            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
8614    }
8615    if let Some(ref local_var_str) = last_updated__lt {
8616        local_var_req_builder = match "multi" {
8617            "multi" => local_var_req_builder.query(
8618                &local_var_str
8619                    .into_iter()
8620                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8622            ),
8623            _ => local_var_req_builder.query(&[(
8624                "last_updated__lt",
8625                &local_var_str
8626                    .into_iter()
8627                    .map(|p| p.to_string())
8628                    .collect::<Vec<String>>()
8629                    .join(",")
8630                    .to_string(),
8631            )]),
8632        };
8633    }
8634    if let Some(ref local_var_str) = last_updated__lte {
8635        local_var_req_builder = match "multi" {
8636            "multi" => local_var_req_builder.query(
8637                &local_var_str
8638                    .into_iter()
8639                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8641            ),
8642            _ => local_var_req_builder.query(&[(
8643                "last_updated__lte",
8644                &local_var_str
8645                    .into_iter()
8646                    .map(|p| p.to_string())
8647                    .collect::<Vec<String>>()
8648                    .join(",")
8649                    .to_string(),
8650            )]),
8651        };
8652    }
8653    if let Some(ref local_var_str) = last_updated__n {
8654        local_var_req_builder = match "multi" {
8655            "multi" => local_var_req_builder.query(
8656                &local_var_str
8657                    .into_iter()
8658                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8660            ),
8661            _ => local_var_req_builder.query(&[(
8662                "last_updated__n",
8663                &local_var_str
8664                    .into_iter()
8665                    .map(|p| p.to_string())
8666                    .collect::<Vec<String>>()
8667                    .join(",")
8668                    .to_string(),
8669            )]),
8670        };
8671    }
8672    if let Some(ref local_var_str) = limit {
8673        local_var_req_builder =
8674            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8675    }
8676    if let Some(ref local_var_str) = name {
8677        local_var_req_builder = match "multi" {
8678            "multi" => local_var_req_builder.query(
8679                &local_var_str
8680                    .into_iter()
8681                    .map(|p| ("name".to_owned(), p.to_string()))
8682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8683            ),
8684            _ => local_var_req_builder.query(&[(
8685                "name",
8686                &local_var_str
8687                    .into_iter()
8688                    .map(|p| p.to_string())
8689                    .collect::<Vec<String>>()
8690                    .join(",")
8691                    .to_string(),
8692            )]),
8693        };
8694    }
8695    if let Some(ref local_var_str) = name__ic {
8696        local_var_req_builder = match "multi" {
8697            "multi" => local_var_req_builder.query(
8698                &local_var_str
8699                    .into_iter()
8700                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8702            ),
8703            _ => local_var_req_builder.query(&[(
8704                "name__ic",
8705                &local_var_str
8706                    .into_iter()
8707                    .map(|p| p.to_string())
8708                    .collect::<Vec<String>>()
8709                    .join(",")
8710                    .to_string(),
8711            )]),
8712        };
8713    }
8714    if let Some(ref local_var_str) = name__ie {
8715        local_var_req_builder = match "multi" {
8716            "multi" => local_var_req_builder.query(
8717                &local_var_str
8718                    .into_iter()
8719                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8721            ),
8722            _ => local_var_req_builder.query(&[(
8723                "name__ie",
8724                &local_var_str
8725                    .into_iter()
8726                    .map(|p| p.to_string())
8727                    .collect::<Vec<String>>()
8728                    .join(",")
8729                    .to_string(),
8730            )]),
8731        };
8732    }
8733    if let Some(ref local_var_str) = name__iew {
8734        local_var_req_builder = match "multi" {
8735            "multi" => local_var_req_builder.query(
8736                &local_var_str
8737                    .into_iter()
8738                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8740            ),
8741            _ => local_var_req_builder.query(&[(
8742                "name__iew",
8743                &local_var_str
8744                    .into_iter()
8745                    .map(|p| p.to_string())
8746                    .collect::<Vec<String>>()
8747                    .join(",")
8748                    .to_string(),
8749            )]),
8750        };
8751    }
8752    if let Some(ref local_var_str) = name__ire {
8753        local_var_req_builder = match "multi" {
8754            "multi" => local_var_req_builder.query(
8755                &local_var_str
8756                    .into_iter()
8757                    .map(|p| ("name__ire".to_owned(), p.to_string()))
8758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8759            ),
8760            _ => local_var_req_builder.query(&[(
8761                "name__ire",
8762                &local_var_str
8763                    .into_iter()
8764                    .map(|p| p.to_string())
8765                    .collect::<Vec<String>>()
8766                    .join(",")
8767                    .to_string(),
8768            )]),
8769        };
8770    }
8771    if let Some(ref local_var_str) = name__isw {
8772        local_var_req_builder = match "multi" {
8773            "multi" => local_var_req_builder.query(
8774                &local_var_str
8775                    .into_iter()
8776                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8778            ),
8779            _ => local_var_req_builder.query(&[(
8780                "name__isw",
8781                &local_var_str
8782                    .into_iter()
8783                    .map(|p| p.to_string())
8784                    .collect::<Vec<String>>()
8785                    .join(",")
8786                    .to_string(),
8787            )]),
8788        };
8789    }
8790    if let Some(ref local_var_str) = name__n {
8791        local_var_req_builder = match "multi" {
8792            "multi" => local_var_req_builder.query(
8793                &local_var_str
8794                    .into_iter()
8795                    .map(|p| ("name__n".to_owned(), p.to_string()))
8796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8797            ),
8798            _ => local_var_req_builder.query(&[(
8799                "name__n",
8800                &local_var_str
8801                    .into_iter()
8802                    .map(|p| p.to_string())
8803                    .collect::<Vec<String>>()
8804                    .join(",")
8805                    .to_string(),
8806            )]),
8807        };
8808    }
8809    if let Some(ref local_var_str) = name__nic {
8810        local_var_req_builder = match "multi" {
8811            "multi" => local_var_req_builder.query(
8812                &local_var_str
8813                    .into_iter()
8814                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8816            ),
8817            _ => local_var_req_builder.query(&[(
8818                "name__nic",
8819                &local_var_str
8820                    .into_iter()
8821                    .map(|p| p.to_string())
8822                    .collect::<Vec<String>>()
8823                    .join(",")
8824                    .to_string(),
8825            )]),
8826        };
8827    }
8828    if let Some(ref local_var_str) = name__nie {
8829        local_var_req_builder = match "multi" {
8830            "multi" => local_var_req_builder.query(
8831                &local_var_str
8832                    .into_iter()
8833                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8835            ),
8836            _ => local_var_req_builder.query(&[(
8837                "name__nie",
8838                &local_var_str
8839                    .into_iter()
8840                    .map(|p| p.to_string())
8841                    .collect::<Vec<String>>()
8842                    .join(",")
8843                    .to_string(),
8844            )]),
8845        };
8846    }
8847    if let Some(ref local_var_str) = name__niew {
8848        local_var_req_builder = match "multi" {
8849            "multi" => local_var_req_builder.query(
8850                &local_var_str
8851                    .into_iter()
8852                    .map(|p| ("name__niew".to_owned(), p.to_string()))
8853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8854            ),
8855            _ => local_var_req_builder.query(&[(
8856                "name__niew",
8857                &local_var_str
8858                    .into_iter()
8859                    .map(|p| p.to_string())
8860                    .collect::<Vec<String>>()
8861                    .join(",")
8862                    .to_string(),
8863            )]),
8864        };
8865    }
8866    if let Some(ref local_var_str) = name__nire {
8867        local_var_req_builder = match "multi" {
8868            "multi" => local_var_req_builder.query(
8869                &local_var_str
8870                    .into_iter()
8871                    .map(|p| ("name__nire".to_owned(), p.to_string()))
8872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8873            ),
8874            _ => local_var_req_builder.query(&[(
8875                "name__nire",
8876                &local_var_str
8877                    .into_iter()
8878                    .map(|p| p.to_string())
8879                    .collect::<Vec<String>>()
8880                    .join(",")
8881                    .to_string(),
8882            )]),
8883        };
8884    }
8885    if let Some(ref local_var_str) = name__nisw {
8886        local_var_req_builder = match "multi" {
8887            "multi" => local_var_req_builder.query(
8888                &local_var_str
8889                    .into_iter()
8890                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
8891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8892            ),
8893            _ => local_var_req_builder.query(&[(
8894                "name__nisw",
8895                &local_var_str
8896                    .into_iter()
8897                    .map(|p| p.to_string())
8898                    .collect::<Vec<String>>()
8899                    .join(",")
8900                    .to_string(),
8901            )]),
8902        };
8903    }
8904    if let Some(ref local_var_str) = name__nre {
8905        local_var_req_builder = match "multi" {
8906            "multi" => local_var_req_builder.query(
8907                &local_var_str
8908                    .into_iter()
8909                    .map(|p| ("name__nre".to_owned(), p.to_string()))
8910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8911            ),
8912            _ => local_var_req_builder.query(&[(
8913                "name__nre",
8914                &local_var_str
8915                    .into_iter()
8916                    .map(|p| p.to_string())
8917                    .collect::<Vec<String>>()
8918                    .join(",")
8919                    .to_string(),
8920            )]),
8921        };
8922    }
8923    if let Some(ref local_var_str) = name__re {
8924        local_var_req_builder = match "multi" {
8925            "multi" => local_var_req_builder.query(
8926                &local_var_str
8927                    .into_iter()
8928                    .map(|p| ("name__re".to_owned(), p.to_string()))
8929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8930            ),
8931            _ => local_var_req_builder.query(&[(
8932                "name__re",
8933                &local_var_str
8934                    .into_iter()
8935                    .map(|p| p.to_string())
8936                    .collect::<Vec<String>>()
8937                    .join(",")
8938                    .to_string(),
8939            )]),
8940        };
8941    }
8942    if let Some(ref local_var_str) = offset {
8943        local_var_req_builder =
8944            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8945    }
8946    if let Some(ref local_var_str) = provider {
8947        local_var_req_builder = match "multi" {
8948            "multi" => local_var_req_builder.query(
8949                &local_var_str
8950                    .into_iter()
8951                    .map(|p| ("provider".to_owned(), p.to_string()))
8952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8953            ),
8954            _ => local_var_req_builder.query(&[(
8955                "provider",
8956                &local_var_str
8957                    .into_iter()
8958                    .map(|p| p.to_string())
8959                    .collect::<Vec<String>>()
8960                    .join(",")
8961                    .to_string(),
8962            )]),
8963        };
8964    }
8965    if let Some(ref local_var_str) = provider__n {
8966        local_var_req_builder = match "multi" {
8967            "multi" => local_var_req_builder.query(
8968                &local_var_str
8969                    .into_iter()
8970                    .map(|p| ("provider__n".to_owned(), p.to_string()))
8971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8972            ),
8973            _ => local_var_req_builder.query(&[(
8974                "provider__n",
8975                &local_var_str
8976                    .into_iter()
8977                    .map(|p| p.to_string())
8978                    .collect::<Vec<String>>()
8979                    .join(",")
8980                    .to_string(),
8981            )]),
8982        };
8983    }
8984    if let Some(ref local_var_str) = q {
8985        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8986    }
8987    if let Some(ref local_var_str) = sort {
8988        local_var_req_builder =
8989            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
8990    }
8991    if let Some(ref local_var_str) = tags {
8992        local_var_req_builder = match "multi" {
8993            "multi" => local_var_req_builder.query(
8994                &local_var_str
8995                    .into_iter()
8996                    .map(|p| ("tags".to_owned(), p.to_string()))
8997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8998            ),
8999            _ => local_var_req_builder.query(&[(
9000                "tags",
9001                &local_var_str
9002                    .into_iter()
9003                    .map(|p| p.to_string())
9004                    .collect::<Vec<String>>()
9005                    .join(",")
9006                    .to_string(),
9007            )]),
9008        };
9009    }
9010    if let Some(ref local_var_str) = tags__isnull {
9011        local_var_req_builder =
9012            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
9013    }
9014    if let Some(ref local_var_str) = tags__n {
9015        local_var_req_builder = match "multi" {
9016            "multi" => local_var_req_builder.query(
9017                &local_var_str
9018                    .into_iter()
9019                    .map(|p| ("tags__n".to_owned(), p.to_string()))
9020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9021            ),
9022            _ => local_var_req_builder.query(&[(
9023                "tags__n",
9024                &local_var_str
9025                    .into_iter()
9026                    .map(|p| p.to_string())
9027                    .collect::<Vec<String>>()
9028                    .join(",")
9029                    .to_string(),
9030            )]),
9031        };
9032    }
9033    if let Some(ref local_var_str) = teams {
9034        local_var_req_builder = match "multi" {
9035            "multi" => local_var_req_builder.query(
9036                &local_var_str
9037                    .into_iter()
9038                    .map(|p| ("teams".to_owned(), p.to_string()))
9039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9040            ),
9041            _ => local_var_req_builder.query(&[(
9042                "teams",
9043                &local_var_str
9044                    .into_iter()
9045                    .map(|p| p.to_string())
9046                    .collect::<Vec<String>>()
9047                    .join(",")
9048                    .to_string(),
9049            )]),
9050        };
9051    }
9052    if let Some(ref local_var_str) = teams__isnull {
9053        local_var_req_builder =
9054            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
9055    }
9056    if let Some(ref local_var_str) = teams__n {
9057        local_var_req_builder = match "multi" {
9058            "multi" => local_var_req_builder.query(
9059                &local_var_str
9060                    .into_iter()
9061                    .map(|p| ("teams__n".to_owned(), p.to_string()))
9062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9063            ),
9064            _ => local_var_req_builder.query(&[(
9065                "teams__n",
9066                &local_var_str
9067                    .into_iter()
9068                    .map(|p| p.to_string())
9069                    .collect::<Vec<String>>()
9070                    .join(",")
9071                    .to_string(),
9072            )]),
9073        };
9074    }
9075    if let Some(ref local_var_str) = depth {
9076        local_var_req_builder =
9077            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9078    }
9079    if let Some(ref local_var_str) = exclude_m2m {
9080        local_var_req_builder =
9081            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9082    }
9083    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9084        local_var_req_builder =
9085            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9086    }
9087    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9088        let local_var_key = local_var_apikey.key.clone();
9089        let local_var_value = match local_var_apikey.prefix {
9090            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9091            None => local_var_key,
9092        };
9093        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9094    };
9095
9096    let local_var_req = local_var_req_builder.build()?;
9097    let local_var_resp = local_var_client.execute(local_var_req).await?;
9098
9099    let local_var_status = local_var_resp.status();
9100    let local_var_content = local_var_resp.text().await?;
9101
9102    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9103        serde_json::from_str(&local_var_content).map_err(Error::from)
9104    } else {
9105        let local_var_entity: Option<CircuitsProviderNetworksListError> =
9106            serde_json::from_str(&local_var_content).ok();
9107        let local_var_error = ResponseContent {
9108            status: local_var_status,
9109            content: local_var_content,
9110            entity: local_var_entity,
9111        };
9112        Err(Error::ResponseError(local_var_error))
9113    }
9114}
9115
9116/// API methods for returning or creating notes on an object.
9117pub async fn circuits_provider_networks_notes_create(
9118    configuration: &configuration::Configuration,
9119    id: &str,
9120    note_input_request: crate::models::NoteInputRequest,
9121    format: Option<&str>,
9122) -> Result<crate::models::Note, Error<CircuitsProviderNetworksNotesCreateError>> {
9123    let local_var_configuration = configuration;
9124
9125    let local_var_client = &local_var_configuration.client;
9126
9127    let local_var_uri_str = format!(
9128        "{}/circuits/provider-networks/{id}/notes/",
9129        local_var_configuration.base_path,
9130        id = crate::apis::urlencode(id)
9131    );
9132    let mut local_var_req_builder =
9133        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9134
9135    if let Some(ref local_var_str) = format {
9136        local_var_req_builder =
9137            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9138    }
9139    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9140        local_var_req_builder =
9141            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9142    }
9143    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9144        let local_var_key = local_var_apikey.key.clone();
9145        let local_var_value = match local_var_apikey.prefix {
9146            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9147            None => local_var_key,
9148        };
9149        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9150    };
9151    local_var_req_builder = local_var_req_builder.json(&note_input_request);
9152
9153    let local_var_req = local_var_req_builder.build()?;
9154    let local_var_resp = local_var_client.execute(local_var_req).await?;
9155
9156    let local_var_status = local_var_resp.status();
9157    let local_var_content = local_var_resp.text().await?;
9158
9159    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9160        serde_json::from_str(&local_var_content).map_err(Error::from)
9161    } else {
9162        let local_var_entity: Option<CircuitsProviderNetworksNotesCreateError> =
9163            serde_json::from_str(&local_var_content).ok();
9164        let local_var_error = ResponseContent {
9165            status: local_var_status,
9166            content: local_var_content,
9167            entity: local_var_entity,
9168        };
9169        Err(Error::ResponseError(local_var_error))
9170    }
9171}
9172
9173/// API methods for returning or creating notes on an object.
9174pub async fn circuits_provider_networks_notes_list(
9175    configuration: &configuration::Configuration,
9176    id: &str,
9177    format: Option<&str>,
9178    limit: Option<i32>,
9179    offset: Option<i32>,
9180    depth: Option<i32>,
9181    exclude_m2m: Option<bool>,
9182) -> Result<crate::models::PaginatedNoteList, Error<CircuitsProviderNetworksNotesListError>> {
9183    let local_var_configuration = configuration;
9184
9185    let local_var_client = &local_var_configuration.client;
9186
9187    let local_var_uri_str = format!(
9188        "{}/circuits/provider-networks/{id}/notes/",
9189        local_var_configuration.base_path,
9190        id = crate::apis::urlencode(id)
9191    );
9192    let mut local_var_req_builder =
9193        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9194
9195    if let Some(ref local_var_str) = format {
9196        local_var_req_builder =
9197            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9198    }
9199    if let Some(ref local_var_str) = limit {
9200        local_var_req_builder =
9201            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9202    }
9203    if let Some(ref local_var_str) = offset {
9204        local_var_req_builder =
9205            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9206    }
9207    if let Some(ref local_var_str) = depth {
9208        local_var_req_builder =
9209            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9210    }
9211    if let Some(ref local_var_str) = exclude_m2m {
9212        local_var_req_builder =
9213            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9214    }
9215    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9216        local_var_req_builder =
9217            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9218    }
9219    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9220        let local_var_key = local_var_apikey.key.clone();
9221        let local_var_value = match local_var_apikey.prefix {
9222            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9223            None => local_var_key,
9224        };
9225        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9226    };
9227
9228    let local_var_req = local_var_req_builder.build()?;
9229    let local_var_resp = local_var_client.execute(local_var_req).await?;
9230
9231    let local_var_status = local_var_resp.status();
9232    let local_var_content = local_var_resp.text().await?;
9233
9234    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9235        serde_json::from_str(&local_var_content).map_err(Error::from)
9236    } else {
9237        let local_var_entity: Option<CircuitsProviderNetworksNotesListError> =
9238            serde_json::from_str(&local_var_content).ok();
9239        let local_var_error = ResponseContent {
9240            status: local_var_status,
9241            content: local_var_content,
9242            entity: local_var_entity,
9243        };
9244        Err(Error::ResponseError(local_var_error))
9245    }
9246}
9247
9248/// Partial update a provider network object.
9249pub async fn circuits_provider_networks_partial_update(
9250    configuration: &configuration::Configuration,
9251    id: &str,
9252    format: Option<&str>,
9253    patched_provider_network_request: Option<crate::models::PatchedProviderNetworkRequest>,
9254) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksPartialUpdateError>> {
9255    let local_var_configuration = configuration;
9256
9257    let local_var_client = &local_var_configuration.client;
9258
9259    let local_var_uri_str = format!(
9260        "{}/circuits/provider-networks/{id}/",
9261        local_var_configuration.base_path,
9262        id = crate::apis::urlencode(id)
9263    );
9264    let mut local_var_req_builder =
9265        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9266
9267    if let Some(ref local_var_str) = format {
9268        local_var_req_builder =
9269            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9270    }
9271    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9272        local_var_req_builder =
9273            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9274    }
9275    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9276        let local_var_key = local_var_apikey.key.clone();
9277        let local_var_value = match local_var_apikey.prefix {
9278            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9279            None => local_var_key,
9280        };
9281        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9282    };
9283    local_var_req_builder = local_var_req_builder.json(&patched_provider_network_request);
9284
9285    let local_var_req = local_var_req_builder.build()?;
9286    let local_var_resp = local_var_client.execute(local_var_req).await?;
9287
9288    let local_var_status = local_var_resp.status();
9289    let local_var_content = local_var_resp.text().await?;
9290
9291    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9292        serde_json::from_str(&local_var_content).map_err(Error::from)
9293    } else {
9294        let local_var_entity: Option<CircuitsProviderNetworksPartialUpdateError> =
9295            serde_json::from_str(&local_var_content).ok();
9296        let local_var_error = ResponseContent {
9297            status: local_var_status,
9298            content: local_var_content,
9299            entity: local_var_entity,
9300        };
9301        Err(Error::ResponseError(local_var_error))
9302    }
9303}
9304
9305/// Retrieve a provider network object.
9306pub async fn circuits_provider_networks_retrieve(
9307    configuration: &configuration::Configuration,
9308    id: &str,
9309    format: Option<&str>,
9310    depth: Option<i32>,
9311    exclude_m2m: Option<bool>,
9312) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksRetrieveError>> {
9313    let local_var_configuration = configuration;
9314
9315    let local_var_client = &local_var_configuration.client;
9316
9317    let local_var_uri_str = format!(
9318        "{}/circuits/provider-networks/{id}/",
9319        local_var_configuration.base_path,
9320        id = crate::apis::urlencode(id)
9321    );
9322    let mut local_var_req_builder =
9323        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9324
9325    if let Some(ref local_var_str) = format {
9326        local_var_req_builder =
9327            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9328    }
9329    if let Some(ref local_var_str) = depth {
9330        local_var_req_builder =
9331            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9332    }
9333    if let Some(ref local_var_str) = exclude_m2m {
9334        local_var_req_builder =
9335            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9336    }
9337    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9338        local_var_req_builder =
9339            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9340    }
9341    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9342        let local_var_key = local_var_apikey.key.clone();
9343        let local_var_value = match local_var_apikey.prefix {
9344            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9345            None => local_var_key,
9346        };
9347        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9348    };
9349
9350    let local_var_req = local_var_req_builder.build()?;
9351    let local_var_resp = local_var_client.execute(local_var_req).await?;
9352
9353    let local_var_status = local_var_resp.status();
9354    let local_var_content = local_var_resp.text().await?;
9355
9356    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9357        serde_json::from_str(&local_var_content).map_err(Error::from)
9358    } else {
9359        let local_var_entity: Option<CircuitsProviderNetworksRetrieveError> =
9360            serde_json::from_str(&local_var_content).ok();
9361        let local_var_error = ResponseContent {
9362            status: local_var_status,
9363            content: local_var_content,
9364            entity: local_var_entity,
9365        };
9366        Err(Error::ResponseError(local_var_error))
9367    }
9368}
9369
9370/// Update a provider network object.
9371pub async fn circuits_provider_networks_update(
9372    configuration: &configuration::Configuration,
9373    id: &str,
9374    provider_network_request: crate::models::ProviderNetworkRequest,
9375    format: Option<&str>,
9376) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksUpdateError>> {
9377    let local_var_configuration = configuration;
9378
9379    let local_var_client = &local_var_configuration.client;
9380
9381    let local_var_uri_str = format!(
9382        "{}/circuits/provider-networks/{id}/",
9383        local_var_configuration.base_path,
9384        id = crate::apis::urlencode(id)
9385    );
9386    let mut local_var_req_builder =
9387        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9388
9389    if let Some(ref local_var_str) = format {
9390        local_var_req_builder =
9391            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9392    }
9393    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9394        local_var_req_builder =
9395            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9396    }
9397    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9398        let local_var_key = local_var_apikey.key.clone();
9399        let local_var_value = match local_var_apikey.prefix {
9400            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9401            None => local_var_key,
9402        };
9403        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9404    };
9405    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
9406
9407    let local_var_req = local_var_req_builder.build()?;
9408    let local_var_resp = local_var_client.execute(local_var_req).await?;
9409
9410    let local_var_status = local_var_resp.status();
9411    let local_var_content = local_var_resp.text().await?;
9412
9413    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9414        serde_json::from_str(&local_var_content).map_err(Error::from)
9415    } else {
9416        let local_var_entity: Option<CircuitsProviderNetworksUpdateError> =
9417            serde_json::from_str(&local_var_content).ok();
9418        let local_var_error = ResponseContent {
9419            status: local_var_status,
9420            content: local_var_content,
9421            entity: local_var_entity,
9422        };
9423        Err(Error::ResponseError(local_var_error))
9424    }
9425}
9426
9427/// Destroy a list of provider objects.
9428pub async fn circuits_providers_bulk_destroy(
9429    configuration: &configuration::Configuration,
9430    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
9431    format: Option<&str>,
9432) -> Result<(), Error<CircuitsProvidersBulkDestroyError>> {
9433    let local_var_configuration = configuration;
9434
9435    let local_var_client = &local_var_configuration.client;
9436
9437    let local_var_uri_str = format!("{}/circuits/providers/", local_var_configuration.base_path);
9438    let mut local_var_req_builder =
9439        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9440
9441    if let Some(ref local_var_str) = format {
9442        local_var_req_builder =
9443            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9444    }
9445    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9446        local_var_req_builder =
9447            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9448    }
9449    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9450        let local_var_key = local_var_apikey.key.clone();
9451        let local_var_value = match local_var_apikey.prefix {
9452            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9453            None => local_var_key,
9454        };
9455        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9456    };
9457    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
9458
9459    let local_var_req = local_var_req_builder.build()?;
9460    let local_var_resp = local_var_client.execute(local_var_req).await?;
9461
9462    let local_var_status = local_var_resp.status();
9463    let local_var_content = local_var_resp.text().await?;
9464
9465    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9466        Ok(())
9467    } else {
9468        let local_var_entity: Option<CircuitsProvidersBulkDestroyError> =
9469            serde_json::from_str(&local_var_content).ok();
9470        let local_var_error = ResponseContent {
9471            status: local_var_status,
9472            content: local_var_content,
9473            entity: local_var_entity,
9474        };
9475        Err(Error::ResponseError(local_var_error))
9476    }
9477}
9478
9479/// Partial update a list of provider objects.
9480pub async fn circuits_providers_bulk_partial_update(
9481    configuration: &configuration::Configuration,
9482    patched_bulk_writable_provider_request: Vec<crate::models::PatchedBulkWritableProviderRequest>,
9483    format: Option<&str>,
9484) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkPartialUpdateError>> {
9485    let local_var_configuration = configuration;
9486
9487    let local_var_client = &local_var_configuration.client;
9488
9489    let local_var_uri_str = format!("{}/circuits/providers/", local_var_configuration.base_path);
9490    let mut local_var_req_builder =
9491        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9492
9493    if let Some(ref local_var_str) = format {
9494        local_var_req_builder =
9495            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9496    }
9497    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9498        local_var_req_builder =
9499            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9500    }
9501    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9502        let local_var_key = local_var_apikey.key.clone();
9503        let local_var_value = match local_var_apikey.prefix {
9504            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9505            None => local_var_key,
9506        };
9507        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9508    };
9509    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_provider_request);
9510
9511    let local_var_req = local_var_req_builder.build()?;
9512    let local_var_resp = local_var_client.execute(local_var_req).await?;
9513
9514    let local_var_status = local_var_resp.status();
9515    let local_var_content = local_var_resp.text().await?;
9516
9517    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9518        serde_json::from_str(&local_var_content).map_err(Error::from)
9519    } else {
9520        let local_var_entity: Option<CircuitsProvidersBulkPartialUpdateError> =
9521            serde_json::from_str(&local_var_content).ok();
9522        let local_var_error = ResponseContent {
9523            status: local_var_status,
9524            content: local_var_content,
9525            entity: local_var_entity,
9526        };
9527        Err(Error::ResponseError(local_var_error))
9528    }
9529}
9530
9531/// Update a list of provider objects.
9532pub async fn circuits_providers_bulk_update(
9533    configuration: &configuration::Configuration,
9534    bulk_writable_provider_request: Vec<crate::models::BulkWritableProviderRequest>,
9535    format: Option<&str>,
9536) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkUpdateError>> {
9537    let local_var_configuration = configuration;
9538
9539    let local_var_client = &local_var_configuration.client;
9540
9541    let local_var_uri_str = format!("{}/circuits/providers/", local_var_configuration.base_path);
9542    let mut local_var_req_builder =
9543        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9544
9545    if let Some(ref local_var_str) = format {
9546        local_var_req_builder =
9547            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9548    }
9549    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9550        local_var_req_builder =
9551            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9552    }
9553    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9554        let local_var_key = local_var_apikey.key.clone();
9555        let local_var_value = match local_var_apikey.prefix {
9556            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9557            None => local_var_key,
9558        };
9559        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9560    };
9561    local_var_req_builder = local_var_req_builder.json(&bulk_writable_provider_request);
9562
9563    let local_var_req = local_var_req_builder.build()?;
9564    let local_var_resp = local_var_client.execute(local_var_req).await?;
9565
9566    let local_var_status = local_var_resp.status();
9567    let local_var_content = local_var_resp.text().await?;
9568
9569    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9570        serde_json::from_str(&local_var_content).map_err(Error::from)
9571    } else {
9572        let local_var_entity: Option<CircuitsProvidersBulkUpdateError> =
9573            serde_json::from_str(&local_var_content).ok();
9574        let local_var_error = ResponseContent {
9575            status: local_var_status,
9576            content: local_var_content,
9577            entity: local_var_entity,
9578        };
9579        Err(Error::ResponseError(local_var_error))
9580    }
9581}
9582
9583/// Create one or more provider objects.
9584pub async fn circuits_providers_create(
9585    configuration: &configuration::Configuration,
9586    provider_request: crate::models::ProviderRequest,
9587    format: Option<&str>,
9588) -> Result<crate::models::Provider, Error<CircuitsProvidersCreateError>> {
9589    let local_var_configuration = configuration;
9590
9591    let local_var_client = &local_var_configuration.client;
9592
9593    let local_var_uri_str = format!("{}/circuits/providers/", local_var_configuration.base_path);
9594    let mut local_var_req_builder =
9595        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9596
9597    if let Some(ref local_var_str) = format {
9598        local_var_req_builder =
9599            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9600    }
9601    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9602        local_var_req_builder =
9603            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9604    }
9605    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9606        let local_var_key = local_var_apikey.key.clone();
9607        let local_var_value = match local_var_apikey.prefix {
9608            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9609            None => local_var_key,
9610        };
9611        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9612    };
9613    local_var_req_builder = local_var_req_builder.json(&provider_request);
9614
9615    let local_var_req = local_var_req_builder.build()?;
9616    let local_var_resp = local_var_client.execute(local_var_req).await?;
9617
9618    let local_var_status = local_var_resp.status();
9619    let local_var_content = local_var_resp.text().await?;
9620
9621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9622        serde_json::from_str(&local_var_content).map_err(Error::from)
9623    } else {
9624        let local_var_entity: Option<CircuitsProvidersCreateError> =
9625            serde_json::from_str(&local_var_content).ok();
9626        let local_var_error = ResponseContent {
9627            status: local_var_status,
9628            content: local_var_content,
9629            entity: local_var_entity,
9630        };
9631        Err(Error::ResponseError(local_var_error))
9632    }
9633}
9634
9635/// Destroy a provider object.
9636pub async fn circuits_providers_destroy(
9637    configuration: &configuration::Configuration,
9638    id: &str,
9639    format: Option<&str>,
9640) -> Result<(), Error<CircuitsProvidersDestroyError>> {
9641    let local_var_configuration = configuration;
9642
9643    let local_var_client = &local_var_configuration.client;
9644
9645    let local_var_uri_str = format!(
9646        "{}/circuits/providers/{id}/",
9647        local_var_configuration.base_path,
9648        id = crate::apis::urlencode(id)
9649    );
9650    let mut local_var_req_builder =
9651        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9652
9653    if let Some(ref local_var_str) = format {
9654        local_var_req_builder =
9655            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9656    }
9657    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9658        local_var_req_builder =
9659            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9660    }
9661    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9662        let local_var_key = local_var_apikey.key.clone();
9663        let local_var_value = match local_var_apikey.prefix {
9664            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9665            None => local_var_key,
9666        };
9667        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9668    };
9669
9670    let local_var_req = local_var_req_builder.build()?;
9671    let local_var_resp = local_var_client.execute(local_var_req).await?;
9672
9673    let local_var_status = local_var_resp.status();
9674    let local_var_content = local_var_resp.text().await?;
9675
9676    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9677        Ok(())
9678    } else {
9679        let local_var_entity: Option<CircuitsProvidersDestroyError> =
9680            serde_json::from_str(&local_var_content).ok();
9681        let local_var_error = ResponseContent {
9682            status: local_var_status,
9683            content: local_var_content,
9684            entity: local_var_entity,
9685        };
9686        Err(Error::ResponseError(local_var_error))
9687    }
9688}
9689
9690/// Retrieve a list of provider objects.
9691pub async fn circuits_providers_list(
9692    configuration: &configuration::Configuration,
9693    account: Option<Vec<String>>,
9694    account__ic: Option<Vec<String>>,
9695    account__ie: Option<Vec<String>>,
9696    account__iew: Option<Vec<String>>,
9697    account__ire: Option<Vec<String>>,
9698    account__isw: Option<Vec<String>>,
9699    account__n: Option<Vec<String>>,
9700    account__nic: Option<Vec<String>>,
9701    account__nie: Option<Vec<String>>,
9702    account__niew: Option<Vec<String>>,
9703    account__nire: Option<Vec<String>>,
9704    account__nisw: Option<Vec<String>>,
9705    account__nre: Option<Vec<String>>,
9706    account__re: Option<Vec<String>>,
9707    admin_contact: Option<Vec<String>>,
9708    admin_contact__ic: Option<Vec<String>>,
9709    admin_contact__ie: Option<Vec<String>>,
9710    admin_contact__iew: Option<Vec<String>>,
9711    admin_contact__ire: Option<Vec<String>>,
9712    admin_contact__isw: Option<Vec<String>>,
9713    admin_contact__n: Option<Vec<String>>,
9714    admin_contact__nic: Option<Vec<String>>,
9715    admin_contact__nie: Option<Vec<String>>,
9716    admin_contact__niew: Option<Vec<String>>,
9717    admin_contact__nire: Option<Vec<String>>,
9718    admin_contact__nisw: Option<Vec<String>>,
9719    admin_contact__nre: Option<Vec<String>>,
9720    admin_contact__re: Option<Vec<String>>,
9721    asn: Option<Vec<i32>>,
9722    asn__gt: Option<Vec<i32>>,
9723    asn__gte: Option<Vec<i32>>,
9724    asn__isnull: Option<bool>,
9725    asn__lt: Option<Vec<i32>>,
9726    asn__lte: Option<Vec<i32>>,
9727    asn__n: Option<Vec<i32>>,
9728    circuits: Option<Vec<String>>,
9729    circuits__isnull: Option<bool>,
9730    circuits__n: Option<Vec<String>>,
9731    comments: Option<Vec<String>>,
9732    comments__ic: Option<Vec<String>>,
9733    comments__ie: Option<Vec<String>>,
9734    comments__iew: Option<Vec<String>>,
9735    comments__ire: Option<Vec<String>>,
9736    comments__isw: Option<Vec<String>>,
9737    comments__n: Option<Vec<String>>,
9738    comments__nic: Option<Vec<String>>,
9739    comments__nie: Option<Vec<String>>,
9740    comments__niew: Option<Vec<String>>,
9741    comments__nire: Option<Vec<String>>,
9742    comments__nisw: Option<Vec<String>>,
9743    comments__nre: Option<Vec<String>>,
9744    comments__re: Option<Vec<String>>,
9745    contacts: Option<Vec<String>>,
9746    contacts__isnull: Option<bool>,
9747    contacts__n: Option<Vec<String>>,
9748    created: Option<Vec<String>>,
9749    created__gt: Option<Vec<String>>,
9750    created__gte: Option<Vec<String>>,
9751    created__isnull: Option<bool>,
9752    created__lt: Option<Vec<String>>,
9753    created__lte: Option<Vec<String>>,
9754    created__n: Option<Vec<String>>,
9755    dynamic_groups: Option<Vec<String>>,
9756    dynamic_groups__n: Option<Vec<String>>,
9757    format: Option<&str>,
9758    has_circuits: Option<bool>,
9759    has_provider_networks: Option<bool>,
9760    id: Option<Vec<uuid::Uuid>>,
9761    id__n: Option<Vec<uuid::Uuid>>,
9762    last_updated: Option<Vec<String>>,
9763    last_updated__gt: Option<Vec<String>>,
9764    last_updated__gte: Option<Vec<String>>,
9765    last_updated__isnull: Option<bool>,
9766    last_updated__lt: Option<Vec<String>>,
9767    last_updated__lte: Option<Vec<String>>,
9768    last_updated__n: Option<Vec<String>>,
9769    limit: Option<i32>,
9770    location: Option<Vec<String>>,
9771    location__isnull: Option<bool>,
9772    location__n: Option<Vec<String>>,
9773    name: Option<Vec<String>>,
9774    name__ic: Option<Vec<String>>,
9775    name__ie: Option<Vec<String>>,
9776    name__iew: Option<Vec<String>>,
9777    name__ire: Option<Vec<String>>,
9778    name__isw: Option<Vec<String>>,
9779    name__n: Option<Vec<String>>,
9780    name__nic: Option<Vec<String>>,
9781    name__nie: Option<Vec<String>>,
9782    name__niew: Option<Vec<String>>,
9783    name__nire: Option<Vec<String>>,
9784    name__nisw: Option<Vec<String>>,
9785    name__nre: Option<Vec<String>>,
9786    name__re: Option<Vec<String>>,
9787    noc_contact: Option<Vec<String>>,
9788    noc_contact__ic: Option<Vec<String>>,
9789    noc_contact__ie: Option<Vec<String>>,
9790    noc_contact__iew: Option<Vec<String>>,
9791    noc_contact__ire: Option<Vec<String>>,
9792    noc_contact__isw: Option<Vec<String>>,
9793    noc_contact__n: Option<Vec<String>>,
9794    noc_contact__nic: Option<Vec<String>>,
9795    noc_contact__nie: Option<Vec<String>>,
9796    noc_contact__niew: Option<Vec<String>>,
9797    noc_contact__nire: Option<Vec<String>>,
9798    noc_contact__nisw: Option<Vec<String>>,
9799    noc_contact__nre: Option<Vec<String>>,
9800    noc_contact__re: Option<Vec<String>>,
9801    offset: Option<i32>,
9802    portal_url: Option<Vec<String>>,
9803    portal_url__ic: Option<Vec<String>>,
9804    portal_url__ie: Option<Vec<String>>,
9805    portal_url__iew: Option<Vec<String>>,
9806    portal_url__ire: Option<Vec<String>>,
9807    portal_url__isw: Option<Vec<String>>,
9808    portal_url__n: Option<Vec<String>>,
9809    portal_url__nic: Option<Vec<String>>,
9810    portal_url__nie: Option<Vec<String>>,
9811    portal_url__niew: Option<Vec<String>>,
9812    portal_url__nire: Option<Vec<String>>,
9813    portal_url__nisw: Option<Vec<String>>,
9814    portal_url__nre: Option<Vec<String>>,
9815    portal_url__re: Option<Vec<String>>,
9816    provider_networks: Option<Vec<String>>,
9817    provider_networks__isnull: Option<bool>,
9818    provider_networks__n: Option<Vec<String>>,
9819    q: Option<&str>,
9820    sort: Option<&str>,
9821    tags: Option<Vec<String>>,
9822    tags__isnull: Option<bool>,
9823    tags__n: Option<Vec<String>>,
9824    teams: Option<Vec<String>>,
9825    teams__isnull: Option<bool>,
9826    teams__n: Option<Vec<String>>,
9827    depth: Option<i32>,
9828    exclude_m2m: Option<bool>,
9829) -> Result<crate::models::PaginatedProviderList, Error<CircuitsProvidersListError>> {
9830    let local_var_configuration = configuration;
9831
9832    let local_var_client = &local_var_configuration.client;
9833
9834    let local_var_uri_str = format!("{}/circuits/providers/", local_var_configuration.base_path);
9835    let mut local_var_req_builder =
9836        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9837
9838    if let Some(ref local_var_str) = account {
9839        local_var_req_builder = match "multi" {
9840            "multi" => local_var_req_builder.query(
9841                &local_var_str
9842                    .into_iter()
9843                    .map(|p| ("account".to_owned(), p.to_string()))
9844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9845            ),
9846            _ => local_var_req_builder.query(&[(
9847                "account",
9848                &local_var_str
9849                    .into_iter()
9850                    .map(|p| p.to_string())
9851                    .collect::<Vec<String>>()
9852                    .join(",")
9853                    .to_string(),
9854            )]),
9855        };
9856    }
9857    if let Some(ref local_var_str) = account__ic {
9858        local_var_req_builder = match "multi" {
9859            "multi" => local_var_req_builder.query(
9860                &local_var_str
9861                    .into_iter()
9862                    .map(|p| ("account__ic".to_owned(), p.to_string()))
9863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9864            ),
9865            _ => local_var_req_builder.query(&[(
9866                "account__ic",
9867                &local_var_str
9868                    .into_iter()
9869                    .map(|p| p.to_string())
9870                    .collect::<Vec<String>>()
9871                    .join(",")
9872                    .to_string(),
9873            )]),
9874        };
9875    }
9876    if let Some(ref local_var_str) = account__ie {
9877        local_var_req_builder = match "multi" {
9878            "multi" => local_var_req_builder.query(
9879                &local_var_str
9880                    .into_iter()
9881                    .map(|p| ("account__ie".to_owned(), p.to_string()))
9882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9883            ),
9884            _ => local_var_req_builder.query(&[(
9885                "account__ie",
9886                &local_var_str
9887                    .into_iter()
9888                    .map(|p| p.to_string())
9889                    .collect::<Vec<String>>()
9890                    .join(",")
9891                    .to_string(),
9892            )]),
9893        };
9894    }
9895    if let Some(ref local_var_str) = account__iew {
9896        local_var_req_builder = match "multi" {
9897            "multi" => local_var_req_builder.query(
9898                &local_var_str
9899                    .into_iter()
9900                    .map(|p| ("account__iew".to_owned(), p.to_string()))
9901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9902            ),
9903            _ => local_var_req_builder.query(&[(
9904                "account__iew",
9905                &local_var_str
9906                    .into_iter()
9907                    .map(|p| p.to_string())
9908                    .collect::<Vec<String>>()
9909                    .join(",")
9910                    .to_string(),
9911            )]),
9912        };
9913    }
9914    if let Some(ref local_var_str) = account__ire {
9915        local_var_req_builder = match "multi" {
9916            "multi" => local_var_req_builder.query(
9917                &local_var_str
9918                    .into_iter()
9919                    .map(|p| ("account__ire".to_owned(), p.to_string()))
9920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9921            ),
9922            _ => local_var_req_builder.query(&[(
9923                "account__ire",
9924                &local_var_str
9925                    .into_iter()
9926                    .map(|p| p.to_string())
9927                    .collect::<Vec<String>>()
9928                    .join(",")
9929                    .to_string(),
9930            )]),
9931        };
9932    }
9933    if let Some(ref local_var_str) = account__isw {
9934        local_var_req_builder = match "multi" {
9935            "multi" => local_var_req_builder.query(
9936                &local_var_str
9937                    .into_iter()
9938                    .map(|p| ("account__isw".to_owned(), p.to_string()))
9939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9940            ),
9941            _ => local_var_req_builder.query(&[(
9942                "account__isw",
9943                &local_var_str
9944                    .into_iter()
9945                    .map(|p| p.to_string())
9946                    .collect::<Vec<String>>()
9947                    .join(",")
9948                    .to_string(),
9949            )]),
9950        };
9951    }
9952    if let Some(ref local_var_str) = account__n {
9953        local_var_req_builder = match "multi" {
9954            "multi" => local_var_req_builder.query(
9955                &local_var_str
9956                    .into_iter()
9957                    .map(|p| ("account__n".to_owned(), p.to_string()))
9958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9959            ),
9960            _ => local_var_req_builder.query(&[(
9961                "account__n",
9962                &local_var_str
9963                    .into_iter()
9964                    .map(|p| p.to_string())
9965                    .collect::<Vec<String>>()
9966                    .join(",")
9967                    .to_string(),
9968            )]),
9969        };
9970    }
9971    if let Some(ref local_var_str) = account__nic {
9972        local_var_req_builder = match "multi" {
9973            "multi" => local_var_req_builder.query(
9974                &local_var_str
9975                    .into_iter()
9976                    .map(|p| ("account__nic".to_owned(), p.to_string()))
9977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9978            ),
9979            _ => local_var_req_builder.query(&[(
9980                "account__nic",
9981                &local_var_str
9982                    .into_iter()
9983                    .map(|p| p.to_string())
9984                    .collect::<Vec<String>>()
9985                    .join(",")
9986                    .to_string(),
9987            )]),
9988        };
9989    }
9990    if let Some(ref local_var_str) = account__nie {
9991        local_var_req_builder = match "multi" {
9992            "multi" => local_var_req_builder.query(
9993                &local_var_str
9994                    .into_iter()
9995                    .map(|p| ("account__nie".to_owned(), p.to_string()))
9996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9997            ),
9998            _ => local_var_req_builder.query(&[(
9999                "account__nie",
10000                &local_var_str
10001                    .into_iter()
10002                    .map(|p| p.to_string())
10003                    .collect::<Vec<String>>()
10004                    .join(",")
10005                    .to_string(),
10006            )]),
10007        };
10008    }
10009    if let Some(ref local_var_str) = account__niew {
10010        local_var_req_builder = match "multi" {
10011            "multi" => local_var_req_builder.query(
10012                &local_var_str
10013                    .into_iter()
10014                    .map(|p| ("account__niew".to_owned(), p.to_string()))
10015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10016            ),
10017            _ => local_var_req_builder.query(&[(
10018                "account__niew",
10019                &local_var_str
10020                    .into_iter()
10021                    .map(|p| p.to_string())
10022                    .collect::<Vec<String>>()
10023                    .join(",")
10024                    .to_string(),
10025            )]),
10026        };
10027    }
10028    if let Some(ref local_var_str) = account__nire {
10029        local_var_req_builder = match "multi" {
10030            "multi" => local_var_req_builder.query(
10031                &local_var_str
10032                    .into_iter()
10033                    .map(|p| ("account__nire".to_owned(), p.to_string()))
10034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10035            ),
10036            _ => local_var_req_builder.query(&[(
10037                "account__nire",
10038                &local_var_str
10039                    .into_iter()
10040                    .map(|p| p.to_string())
10041                    .collect::<Vec<String>>()
10042                    .join(",")
10043                    .to_string(),
10044            )]),
10045        };
10046    }
10047    if let Some(ref local_var_str) = account__nisw {
10048        local_var_req_builder = match "multi" {
10049            "multi" => local_var_req_builder.query(
10050                &local_var_str
10051                    .into_iter()
10052                    .map(|p| ("account__nisw".to_owned(), p.to_string()))
10053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10054            ),
10055            _ => local_var_req_builder.query(&[(
10056                "account__nisw",
10057                &local_var_str
10058                    .into_iter()
10059                    .map(|p| p.to_string())
10060                    .collect::<Vec<String>>()
10061                    .join(",")
10062                    .to_string(),
10063            )]),
10064        };
10065    }
10066    if let Some(ref local_var_str) = account__nre {
10067        local_var_req_builder = match "multi" {
10068            "multi" => local_var_req_builder.query(
10069                &local_var_str
10070                    .into_iter()
10071                    .map(|p| ("account__nre".to_owned(), p.to_string()))
10072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10073            ),
10074            _ => local_var_req_builder.query(&[(
10075                "account__nre",
10076                &local_var_str
10077                    .into_iter()
10078                    .map(|p| p.to_string())
10079                    .collect::<Vec<String>>()
10080                    .join(",")
10081                    .to_string(),
10082            )]),
10083        };
10084    }
10085    if let Some(ref local_var_str) = account__re {
10086        local_var_req_builder = match "multi" {
10087            "multi" => local_var_req_builder.query(
10088                &local_var_str
10089                    .into_iter()
10090                    .map(|p| ("account__re".to_owned(), p.to_string()))
10091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10092            ),
10093            _ => local_var_req_builder.query(&[(
10094                "account__re",
10095                &local_var_str
10096                    .into_iter()
10097                    .map(|p| p.to_string())
10098                    .collect::<Vec<String>>()
10099                    .join(",")
10100                    .to_string(),
10101            )]),
10102        };
10103    }
10104    if let Some(ref local_var_str) = admin_contact {
10105        local_var_req_builder = match "multi" {
10106            "multi" => local_var_req_builder.query(
10107                &local_var_str
10108                    .into_iter()
10109                    .map(|p| ("admin_contact".to_owned(), p.to_string()))
10110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10111            ),
10112            _ => local_var_req_builder.query(&[(
10113                "admin_contact",
10114                &local_var_str
10115                    .into_iter()
10116                    .map(|p| p.to_string())
10117                    .collect::<Vec<String>>()
10118                    .join(",")
10119                    .to_string(),
10120            )]),
10121        };
10122    }
10123    if let Some(ref local_var_str) = admin_contact__ic {
10124        local_var_req_builder = match "multi" {
10125            "multi" => local_var_req_builder.query(
10126                &local_var_str
10127                    .into_iter()
10128                    .map(|p| ("admin_contact__ic".to_owned(), p.to_string()))
10129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10130            ),
10131            _ => local_var_req_builder.query(&[(
10132                "admin_contact__ic",
10133                &local_var_str
10134                    .into_iter()
10135                    .map(|p| p.to_string())
10136                    .collect::<Vec<String>>()
10137                    .join(",")
10138                    .to_string(),
10139            )]),
10140        };
10141    }
10142    if let Some(ref local_var_str) = admin_contact__ie {
10143        local_var_req_builder = match "multi" {
10144            "multi" => local_var_req_builder.query(
10145                &local_var_str
10146                    .into_iter()
10147                    .map(|p| ("admin_contact__ie".to_owned(), p.to_string()))
10148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10149            ),
10150            _ => local_var_req_builder.query(&[(
10151                "admin_contact__ie",
10152                &local_var_str
10153                    .into_iter()
10154                    .map(|p| p.to_string())
10155                    .collect::<Vec<String>>()
10156                    .join(",")
10157                    .to_string(),
10158            )]),
10159        };
10160    }
10161    if let Some(ref local_var_str) = admin_contact__iew {
10162        local_var_req_builder = match "multi" {
10163            "multi" => local_var_req_builder.query(
10164                &local_var_str
10165                    .into_iter()
10166                    .map(|p| ("admin_contact__iew".to_owned(), p.to_string()))
10167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10168            ),
10169            _ => local_var_req_builder.query(&[(
10170                "admin_contact__iew",
10171                &local_var_str
10172                    .into_iter()
10173                    .map(|p| p.to_string())
10174                    .collect::<Vec<String>>()
10175                    .join(",")
10176                    .to_string(),
10177            )]),
10178        };
10179    }
10180    if let Some(ref local_var_str) = admin_contact__ire {
10181        local_var_req_builder = match "multi" {
10182            "multi" => local_var_req_builder.query(
10183                &local_var_str
10184                    .into_iter()
10185                    .map(|p| ("admin_contact__ire".to_owned(), p.to_string()))
10186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10187            ),
10188            _ => local_var_req_builder.query(&[(
10189                "admin_contact__ire",
10190                &local_var_str
10191                    .into_iter()
10192                    .map(|p| p.to_string())
10193                    .collect::<Vec<String>>()
10194                    .join(",")
10195                    .to_string(),
10196            )]),
10197        };
10198    }
10199    if let Some(ref local_var_str) = admin_contact__isw {
10200        local_var_req_builder = match "multi" {
10201            "multi" => local_var_req_builder.query(
10202                &local_var_str
10203                    .into_iter()
10204                    .map(|p| ("admin_contact__isw".to_owned(), p.to_string()))
10205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10206            ),
10207            _ => local_var_req_builder.query(&[(
10208                "admin_contact__isw",
10209                &local_var_str
10210                    .into_iter()
10211                    .map(|p| p.to_string())
10212                    .collect::<Vec<String>>()
10213                    .join(",")
10214                    .to_string(),
10215            )]),
10216        };
10217    }
10218    if let Some(ref local_var_str) = admin_contact__n {
10219        local_var_req_builder = match "multi" {
10220            "multi" => local_var_req_builder.query(
10221                &local_var_str
10222                    .into_iter()
10223                    .map(|p| ("admin_contact__n".to_owned(), p.to_string()))
10224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10225            ),
10226            _ => local_var_req_builder.query(&[(
10227                "admin_contact__n",
10228                &local_var_str
10229                    .into_iter()
10230                    .map(|p| p.to_string())
10231                    .collect::<Vec<String>>()
10232                    .join(",")
10233                    .to_string(),
10234            )]),
10235        };
10236    }
10237    if let Some(ref local_var_str) = admin_contact__nic {
10238        local_var_req_builder = match "multi" {
10239            "multi" => local_var_req_builder.query(
10240                &local_var_str
10241                    .into_iter()
10242                    .map(|p| ("admin_contact__nic".to_owned(), p.to_string()))
10243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10244            ),
10245            _ => local_var_req_builder.query(&[(
10246                "admin_contact__nic",
10247                &local_var_str
10248                    .into_iter()
10249                    .map(|p| p.to_string())
10250                    .collect::<Vec<String>>()
10251                    .join(",")
10252                    .to_string(),
10253            )]),
10254        };
10255    }
10256    if let Some(ref local_var_str) = admin_contact__nie {
10257        local_var_req_builder = match "multi" {
10258            "multi" => local_var_req_builder.query(
10259                &local_var_str
10260                    .into_iter()
10261                    .map(|p| ("admin_contact__nie".to_owned(), p.to_string()))
10262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10263            ),
10264            _ => local_var_req_builder.query(&[(
10265                "admin_contact__nie",
10266                &local_var_str
10267                    .into_iter()
10268                    .map(|p| p.to_string())
10269                    .collect::<Vec<String>>()
10270                    .join(",")
10271                    .to_string(),
10272            )]),
10273        };
10274    }
10275    if let Some(ref local_var_str) = admin_contact__niew {
10276        local_var_req_builder = match "multi" {
10277            "multi" => local_var_req_builder.query(
10278                &local_var_str
10279                    .into_iter()
10280                    .map(|p| ("admin_contact__niew".to_owned(), p.to_string()))
10281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10282            ),
10283            _ => local_var_req_builder.query(&[(
10284                "admin_contact__niew",
10285                &local_var_str
10286                    .into_iter()
10287                    .map(|p| p.to_string())
10288                    .collect::<Vec<String>>()
10289                    .join(",")
10290                    .to_string(),
10291            )]),
10292        };
10293    }
10294    if let Some(ref local_var_str) = admin_contact__nire {
10295        local_var_req_builder = match "multi" {
10296            "multi" => local_var_req_builder.query(
10297                &local_var_str
10298                    .into_iter()
10299                    .map(|p| ("admin_contact__nire".to_owned(), p.to_string()))
10300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10301            ),
10302            _ => local_var_req_builder.query(&[(
10303                "admin_contact__nire",
10304                &local_var_str
10305                    .into_iter()
10306                    .map(|p| p.to_string())
10307                    .collect::<Vec<String>>()
10308                    .join(",")
10309                    .to_string(),
10310            )]),
10311        };
10312    }
10313    if let Some(ref local_var_str) = admin_contact__nisw {
10314        local_var_req_builder = match "multi" {
10315            "multi" => local_var_req_builder.query(
10316                &local_var_str
10317                    .into_iter()
10318                    .map(|p| ("admin_contact__nisw".to_owned(), p.to_string()))
10319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10320            ),
10321            _ => local_var_req_builder.query(&[(
10322                "admin_contact__nisw",
10323                &local_var_str
10324                    .into_iter()
10325                    .map(|p| p.to_string())
10326                    .collect::<Vec<String>>()
10327                    .join(",")
10328                    .to_string(),
10329            )]),
10330        };
10331    }
10332    if let Some(ref local_var_str) = admin_contact__nre {
10333        local_var_req_builder = match "multi" {
10334            "multi" => local_var_req_builder.query(
10335                &local_var_str
10336                    .into_iter()
10337                    .map(|p| ("admin_contact__nre".to_owned(), p.to_string()))
10338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10339            ),
10340            _ => local_var_req_builder.query(&[(
10341                "admin_contact__nre",
10342                &local_var_str
10343                    .into_iter()
10344                    .map(|p| p.to_string())
10345                    .collect::<Vec<String>>()
10346                    .join(",")
10347                    .to_string(),
10348            )]),
10349        };
10350    }
10351    if let Some(ref local_var_str) = admin_contact__re {
10352        local_var_req_builder = match "multi" {
10353            "multi" => local_var_req_builder.query(
10354                &local_var_str
10355                    .into_iter()
10356                    .map(|p| ("admin_contact__re".to_owned(), p.to_string()))
10357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10358            ),
10359            _ => local_var_req_builder.query(&[(
10360                "admin_contact__re",
10361                &local_var_str
10362                    .into_iter()
10363                    .map(|p| p.to_string())
10364                    .collect::<Vec<String>>()
10365                    .join(",")
10366                    .to_string(),
10367            )]),
10368        };
10369    }
10370    if let Some(ref local_var_str) = asn {
10371        local_var_req_builder = match "multi" {
10372            "multi" => local_var_req_builder.query(
10373                &local_var_str
10374                    .into_iter()
10375                    .map(|p| ("asn".to_owned(), p.to_string()))
10376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10377            ),
10378            _ => local_var_req_builder.query(&[(
10379                "asn",
10380                &local_var_str
10381                    .into_iter()
10382                    .map(|p| p.to_string())
10383                    .collect::<Vec<String>>()
10384                    .join(",")
10385                    .to_string(),
10386            )]),
10387        };
10388    }
10389    if let Some(ref local_var_str) = asn__gt {
10390        local_var_req_builder = match "multi" {
10391            "multi" => local_var_req_builder.query(
10392                &local_var_str
10393                    .into_iter()
10394                    .map(|p| ("asn__gt".to_owned(), p.to_string()))
10395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10396            ),
10397            _ => local_var_req_builder.query(&[(
10398                "asn__gt",
10399                &local_var_str
10400                    .into_iter()
10401                    .map(|p| p.to_string())
10402                    .collect::<Vec<String>>()
10403                    .join(",")
10404                    .to_string(),
10405            )]),
10406        };
10407    }
10408    if let Some(ref local_var_str) = asn__gte {
10409        local_var_req_builder = match "multi" {
10410            "multi" => local_var_req_builder.query(
10411                &local_var_str
10412                    .into_iter()
10413                    .map(|p| ("asn__gte".to_owned(), p.to_string()))
10414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10415            ),
10416            _ => local_var_req_builder.query(&[(
10417                "asn__gte",
10418                &local_var_str
10419                    .into_iter()
10420                    .map(|p| p.to_string())
10421                    .collect::<Vec<String>>()
10422                    .join(",")
10423                    .to_string(),
10424            )]),
10425        };
10426    }
10427    if let Some(ref local_var_str) = asn__isnull {
10428        local_var_req_builder =
10429            local_var_req_builder.query(&[("asn__isnull", &local_var_str.to_string())]);
10430    }
10431    if let Some(ref local_var_str) = asn__lt {
10432        local_var_req_builder = match "multi" {
10433            "multi" => local_var_req_builder.query(
10434                &local_var_str
10435                    .into_iter()
10436                    .map(|p| ("asn__lt".to_owned(), p.to_string()))
10437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10438            ),
10439            _ => local_var_req_builder.query(&[(
10440                "asn__lt",
10441                &local_var_str
10442                    .into_iter()
10443                    .map(|p| p.to_string())
10444                    .collect::<Vec<String>>()
10445                    .join(",")
10446                    .to_string(),
10447            )]),
10448        };
10449    }
10450    if let Some(ref local_var_str) = asn__lte {
10451        local_var_req_builder = match "multi" {
10452            "multi" => local_var_req_builder.query(
10453                &local_var_str
10454                    .into_iter()
10455                    .map(|p| ("asn__lte".to_owned(), p.to_string()))
10456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10457            ),
10458            _ => local_var_req_builder.query(&[(
10459                "asn__lte",
10460                &local_var_str
10461                    .into_iter()
10462                    .map(|p| p.to_string())
10463                    .collect::<Vec<String>>()
10464                    .join(",")
10465                    .to_string(),
10466            )]),
10467        };
10468    }
10469    if let Some(ref local_var_str) = asn__n {
10470        local_var_req_builder = match "multi" {
10471            "multi" => local_var_req_builder.query(
10472                &local_var_str
10473                    .into_iter()
10474                    .map(|p| ("asn__n".to_owned(), p.to_string()))
10475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10476            ),
10477            _ => local_var_req_builder.query(&[(
10478                "asn__n",
10479                &local_var_str
10480                    .into_iter()
10481                    .map(|p| p.to_string())
10482                    .collect::<Vec<String>>()
10483                    .join(",")
10484                    .to_string(),
10485            )]),
10486        };
10487    }
10488    if let Some(ref local_var_str) = circuits {
10489        local_var_req_builder = match "multi" {
10490            "multi" => local_var_req_builder.query(
10491                &local_var_str
10492                    .into_iter()
10493                    .map(|p| ("circuits".to_owned(), p.to_string()))
10494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10495            ),
10496            _ => local_var_req_builder.query(&[(
10497                "circuits",
10498                &local_var_str
10499                    .into_iter()
10500                    .map(|p| p.to_string())
10501                    .collect::<Vec<String>>()
10502                    .join(",")
10503                    .to_string(),
10504            )]),
10505        };
10506    }
10507    if let Some(ref local_var_str) = circuits__isnull {
10508        local_var_req_builder =
10509            local_var_req_builder.query(&[("circuits__isnull", &local_var_str.to_string())]);
10510    }
10511    if let Some(ref local_var_str) = circuits__n {
10512        local_var_req_builder = match "multi" {
10513            "multi" => local_var_req_builder.query(
10514                &local_var_str
10515                    .into_iter()
10516                    .map(|p| ("circuits__n".to_owned(), p.to_string()))
10517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10518            ),
10519            _ => local_var_req_builder.query(&[(
10520                "circuits__n",
10521                &local_var_str
10522                    .into_iter()
10523                    .map(|p| p.to_string())
10524                    .collect::<Vec<String>>()
10525                    .join(",")
10526                    .to_string(),
10527            )]),
10528        };
10529    }
10530    if let Some(ref local_var_str) = comments {
10531        local_var_req_builder = match "multi" {
10532            "multi" => local_var_req_builder.query(
10533                &local_var_str
10534                    .into_iter()
10535                    .map(|p| ("comments".to_owned(), p.to_string()))
10536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10537            ),
10538            _ => local_var_req_builder.query(&[(
10539                "comments",
10540                &local_var_str
10541                    .into_iter()
10542                    .map(|p| p.to_string())
10543                    .collect::<Vec<String>>()
10544                    .join(",")
10545                    .to_string(),
10546            )]),
10547        };
10548    }
10549    if let Some(ref local_var_str) = comments__ic {
10550        local_var_req_builder = match "multi" {
10551            "multi" => local_var_req_builder.query(
10552                &local_var_str
10553                    .into_iter()
10554                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
10555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10556            ),
10557            _ => local_var_req_builder.query(&[(
10558                "comments__ic",
10559                &local_var_str
10560                    .into_iter()
10561                    .map(|p| p.to_string())
10562                    .collect::<Vec<String>>()
10563                    .join(",")
10564                    .to_string(),
10565            )]),
10566        };
10567    }
10568    if let Some(ref local_var_str) = comments__ie {
10569        local_var_req_builder = match "multi" {
10570            "multi" => local_var_req_builder.query(
10571                &local_var_str
10572                    .into_iter()
10573                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
10574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10575            ),
10576            _ => local_var_req_builder.query(&[(
10577                "comments__ie",
10578                &local_var_str
10579                    .into_iter()
10580                    .map(|p| p.to_string())
10581                    .collect::<Vec<String>>()
10582                    .join(",")
10583                    .to_string(),
10584            )]),
10585        };
10586    }
10587    if let Some(ref local_var_str) = comments__iew {
10588        local_var_req_builder = match "multi" {
10589            "multi" => local_var_req_builder.query(
10590                &local_var_str
10591                    .into_iter()
10592                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
10593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10594            ),
10595            _ => local_var_req_builder.query(&[(
10596                "comments__iew",
10597                &local_var_str
10598                    .into_iter()
10599                    .map(|p| p.to_string())
10600                    .collect::<Vec<String>>()
10601                    .join(",")
10602                    .to_string(),
10603            )]),
10604        };
10605    }
10606    if let Some(ref local_var_str) = comments__ire {
10607        local_var_req_builder = match "multi" {
10608            "multi" => local_var_req_builder.query(
10609                &local_var_str
10610                    .into_iter()
10611                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
10612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10613            ),
10614            _ => local_var_req_builder.query(&[(
10615                "comments__ire",
10616                &local_var_str
10617                    .into_iter()
10618                    .map(|p| p.to_string())
10619                    .collect::<Vec<String>>()
10620                    .join(",")
10621                    .to_string(),
10622            )]),
10623        };
10624    }
10625    if let Some(ref local_var_str) = comments__isw {
10626        local_var_req_builder = match "multi" {
10627            "multi" => local_var_req_builder.query(
10628                &local_var_str
10629                    .into_iter()
10630                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
10631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10632            ),
10633            _ => local_var_req_builder.query(&[(
10634                "comments__isw",
10635                &local_var_str
10636                    .into_iter()
10637                    .map(|p| p.to_string())
10638                    .collect::<Vec<String>>()
10639                    .join(",")
10640                    .to_string(),
10641            )]),
10642        };
10643    }
10644    if let Some(ref local_var_str) = comments__n {
10645        local_var_req_builder = match "multi" {
10646            "multi" => local_var_req_builder.query(
10647                &local_var_str
10648                    .into_iter()
10649                    .map(|p| ("comments__n".to_owned(), p.to_string()))
10650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10651            ),
10652            _ => local_var_req_builder.query(&[(
10653                "comments__n",
10654                &local_var_str
10655                    .into_iter()
10656                    .map(|p| p.to_string())
10657                    .collect::<Vec<String>>()
10658                    .join(",")
10659                    .to_string(),
10660            )]),
10661        };
10662    }
10663    if let Some(ref local_var_str) = comments__nic {
10664        local_var_req_builder = match "multi" {
10665            "multi" => local_var_req_builder.query(
10666                &local_var_str
10667                    .into_iter()
10668                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
10669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10670            ),
10671            _ => local_var_req_builder.query(&[(
10672                "comments__nic",
10673                &local_var_str
10674                    .into_iter()
10675                    .map(|p| p.to_string())
10676                    .collect::<Vec<String>>()
10677                    .join(",")
10678                    .to_string(),
10679            )]),
10680        };
10681    }
10682    if let Some(ref local_var_str) = comments__nie {
10683        local_var_req_builder = match "multi" {
10684            "multi" => local_var_req_builder.query(
10685                &local_var_str
10686                    .into_iter()
10687                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
10688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10689            ),
10690            _ => local_var_req_builder.query(&[(
10691                "comments__nie",
10692                &local_var_str
10693                    .into_iter()
10694                    .map(|p| p.to_string())
10695                    .collect::<Vec<String>>()
10696                    .join(",")
10697                    .to_string(),
10698            )]),
10699        };
10700    }
10701    if let Some(ref local_var_str) = comments__niew {
10702        local_var_req_builder = match "multi" {
10703            "multi" => local_var_req_builder.query(
10704                &local_var_str
10705                    .into_iter()
10706                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
10707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10708            ),
10709            _ => local_var_req_builder.query(&[(
10710                "comments__niew",
10711                &local_var_str
10712                    .into_iter()
10713                    .map(|p| p.to_string())
10714                    .collect::<Vec<String>>()
10715                    .join(",")
10716                    .to_string(),
10717            )]),
10718        };
10719    }
10720    if let Some(ref local_var_str) = comments__nire {
10721        local_var_req_builder = match "multi" {
10722            "multi" => local_var_req_builder.query(
10723                &local_var_str
10724                    .into_iter()
10725                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
10726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10727            ),
10728            _ => local_var_req_builder.query(&[(
10729                "comments__nire",
10730                &local_var_str
10731                    .into_iter()
10732                    .map(|p| p.to_string())
10733                    .collect::<Vec<String>>()
10734                    .join(",")
10735                    .to_string(),
10736            )]),
10737        };
10738    }
10739    if let Some(ref local_var_str) = comments__nisw {
10740        local_var_req_builder = match "multi" {
10741            "multi" => local_var_req_builder.query(
10742                &local_var_str
10743                    .into_iter()
10744                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
10745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10746            ),
10747            _ => local_var_req_builder.query(&[(
10748                "comments__nisw",
10749                &local_var_str
10750                    .into_iter()
10751                    .map(|p| p.to_string())
10752                    .collect::<Vec<String>>()
10753                    .join(",")
10754                    .to_string(),
10755            )]),
10756        };
10757    }
10758    if let Some(ref local_var_str) = comments__nre {
10759        local_var_req_builder = match "multi" {
10760            "multi" => local_var_req_builder.query(
10761                &local_var_str
10762                    .into_iter()
10763                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
10764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10765            ),
10766            _ => local_var_req_builder.query(&[(
10767                "comments__nre",
10768                &local_var_str
10769                    .into_iter()
10770                    .map(|p| p.to_string())
10771                    .collect::<Vec<String>>()
10772                    .join(",")
10773                    .to_string(),
10774            )]),
10775        };
10776    }
10777    if let Some(ref local_var_str) = comments__re {
10778        local_var_req_builder = match "multi" {
10779            "multi" => local_var_req_builder.query(
10780                &local_var_str
10781                    .into_iter()
10782                    .map(|p| ("comments__re".to_owned(), p.to_string()))
10783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10784            ),
10785            _ => local_var_req_builder.query(&[(
10786                "comments__re",
10787                &local_var_str
10788                    .into_iter()
10789                    .map(|p| p.to_string())
10790                    .collect::<Vec<String>>()
10791                    .join(",")
10792                    .to_string(),
10793            )]),
10794        };
10795    }
10796    if let Some(ref local_var_str) = contacts {
10797        local_var_req_builder = match "multi" {
10798            "multi" => local_var_req_builder.query(
10799                &local_var_str
10800                    .into_iter()
10801                    .map(|p| ("contacts".to_owned(), p.to_string()))
10802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10803            ),
10804            _ => local_var_req_builder.query(&[(
10805                "contacts",
10806                &local_var_str
10807                    .into_iter()
10808                    .map(|p| p.to_string())
10809                    .collect::<Vec<String>>()
10810                    .join(",")
10811                    .to_string(),
10812            )]),
10813        };
10814    }
10815    if let Some(ref local_var_str) = contacts__isnull {
10816        local_var_req_builder =
10817            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
10818    }
10819    if let Some(ref local_var_str) = contacts__n {
10820        local_var_req_builder = match "multi" {
10821            "multi" => local_var_req_builder.query(
10822                &local_var_str
10823                    .into_iter()
10824                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
10825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10826            ),
10827            _ => local_var_req_builder.query(&[(
10828                "contacts__n",
10829                &local_var_str
10830                    .into_iter()
10831                    .map(|p| p.to_string())
10832                    .collect::<Vec<String>>()
10833                    .join(",")
10834                    .to_string(),
10835            )]),
10836        };
10837    }
10838    if let Some(ref local_var_str) = created {
10839        local_var_req_builder = match "multi" {
10840            "multi" => local_var_req_builder.query(
10841                &local_var_str
10842                    .into_iter()
10843                    .map(|p| ("created".to_owned(), p.to_string()))
10844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10845            ),
10846            _ => local_var_req_builder.query(&[(
10847                "created",
10848                &local_var_str
10849                    .into_iter()
10850                    .map(|p| p.to_string())
10851                    .collect::<Vec<String>>()
10852                    .join(",")
10853                    .to_string(),
10854            )]),
10855        };
10856    }
10857    if let Some(ref local_var_str) = created__gt {
10858        local_var_req_builder = match "multi" {
10859            "multi" => local_var_req_builder.query(
10860                &local_var_str
10861                    .into_iter()
10862                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10864            ),
10865            _ => local_var_req_builder.query(&[(
10866                "created__gt",
10867                &local_var_str
10868                    .into_iter()
10869                    .map(|p| p.to_string())
10870                    .collect::<Vec<String>>()
10871                    .join(",")
10872                    .to_string(),
10873            )]),
10874        };
10875    }
10876    if let Some(ref local_var_str) = created__gte {
10877        local_var_req_builder = match "multi" {
10878            "multi" => local_var_req_builder.query(
10879                &local_var_str
10880                    .into_iter()
10881                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10883            ),
10884            _ => local_var_req_builder.query(&[(
10885                "created__gte",
10886                &local_var_str
10887                    .into_iter()
10888                    .map(|p| p.to_string())
10889                    .collect::<Vec<String>>()
10890                    .join(",")
10891                    .to_string(),
10892            )]),
10893        };
10894    }
10895    if let Some(ref local_var_str) = created__isnull {
10896        local_var_req_builder =
10897            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
10898    }
10899    if let Some(ref local_var_str) = created__lt {
10900        local_var_req_builder = match "multi" {
10901            "multi" => local_var_req_builder.query(
10902                &local_var_str
10903                    .into_iter()
10904                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10906            ),
10907            _ => local_var_req_builder.query(&[(
10908                "created__lt",
10909                &local_var_str
10910                    .into_iter()
10911                    .map(|p| p.to_string())
10912                    .collect::<Vec<String>>()
10913                    .join(",")
10914                    .to_string(),
10915            )]),
10916        };
10917    }
10918    if let Some(ref local_var_str) = created__lte {
10919        local_var_req_builder = match "multi" {
10920            "multi" => local_var_req_builder.query(
10921                &local_var_str
10922                    .into_iter()
10923                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10925            ),
10926            _ => local_var_req_builder.query(&[(
10927                "created__lte",
10928                &local_var_str
10929                    .into_iter()
10930                    .map(|p| p.to_string())
10931                    .collect::<Vec<String>>()
10932                    .join(",")
10933                    .to_string(),
10934            )]),
10935        };
10936    }
10937    if let Some(ref local_var_str) = created__n {
10938        local_var_req_builder = match "multi" {
10939            "multi" => local_var_req_builder.query(
10940                &local_var_str
10941                    .into_iter()
10942                    .map(|p| ("created__n".to_owned(), p.to_string()))
10943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10944            ),
10945            _ => local_var_req_builder.query(&[(
10946                "created__n",
10947                &local_var_str
10948                    .into_iter()
10949                    .map(|p| p.to_string())
10950                    .collect::<Vec<String>>()
10951                    .join(",")
10952                    .to_string(),
10953            )]),
10954        };
10955    }
10956    if let Some(ref local_var_str) = dynamic_groups {
10957        local_var_req_builder = match "multi" {
10958            "multi" => local_var_req_builder.query(
10959                &local_var_str
10960                    .into_iter()
10961                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
10962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10963            ),
10964            _ => local_var_req_builder.query(&[(
10965                "dynamic_groups",
10966                &local_var_str
10967                    .into_iter()
10968                    .map(|p| p.to_string())
10969                    .collect::<Vec<String>>()
10970                    .join(",")
10971                    .to_string(),
10972            )]),
10973        };
10974    }
10975    if let Some(ref local_var_str) = dynamic_groups__n {
10976        local_var_req_builder = match "multi" {
10977            "multi" => local_var_req_builder.query(
10978                &local_var_str
10979                    .into_iter()
10980                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
10981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10982            ),
10983            _ => local_var_req_builder.query(&[(
10984                "dynamic_groups__n",
10985                &local_var_str
10986                    .into_iter()
10987                    .map(|p| p.to_string())
10988                    .collect::<Vec<String>>()
10989                    .join(",")
10990                    .to_string(),
10991            )]),
10992        };
10993    }
10994    if let Some(ref local_var_str) = format {
10995        local_var_req_builder =
10996            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10997    }
10998    if let Some(ref local_var_str) = has_circuits {
10999        local_var_req_builder =
11000            local_var_req_builder.query(&[("has_circuits", &local_var_str.to_string())]);
11001    }
11002    if let Some(ref local_var_str) = has_provider_networks {
11003        local_var_req_builder =
11004            local_var_req_builder.query(&[("has_provider_networks", &local_var_str.to_string())]);
11005    }
11006    if let Some(ref local_var_str) = id {
11007        local_var_req_builder = match "multi" {
11008            "multi" => local_var_req_builder.query(
11009                &local_var_str
11010                    .into_iter()
11011                    .map(|p| ("id".to_owned(), p.to_string()))
11012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11013            ),
11014            _ => local_var_req_builder.query(&[(
11015                "id",
11016                &local_var_str
11017                    .into_iter()
11018                    .map(|p| p.to_string())
11019                    .collect::<Vec<String>>()
11020                    .join(",")
11021                    .to_string(),
11022            )]),
11023        };
11024    }
11025    if let Some(ref local_var_str) = id__n {
11026        local_var_req_builder = match "multi" {
11027            "multi" => local_var_req_builder.query(
11028                &local_var_str
11029                    .into_iter()
11030                    .map(|p| ("id__n".to_owned(), p.to_string()))
11031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11032            ),
11033            _ => local_var_req_builder.query(&[(
11034                "id__n",
11035                &local_var_str
11036                    .into_iter()
11037                    .map(|p| p.to_string())
11038                    .collect::<Vec<String>>()
11039                    .join(",")
11040                    .to_string(),
11041            )]),
11042        };
11043    }
11044    if let Some(ref local_var_str) = last_updated {
11045        local_var_req_builder = match "multi" {
11046            "multi" => local_var_req_builder.query(
11047                &local_var_str
11048                    .into_iter()
11049                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11051            ),
11052            _ => local_var_req_builder.query(&[(
11053                "last_updated",
11054                &local_var_str
11055                    .into_iter()
11056                    .map(|p| p.to_string())
11057                    .collect::<Vec<String>>()
11058                    .join(",")
11059                    .to_string(),
11060            )]),
11061        };
11062    }
11063    if let Some(ref local_var_str) = last_updated__gt {
11064        local_var_req_builder = match "multi" {
11065            "multi" => local_var_req_builder.query(
11066                &local_var_str
11067                    .into_iter()
11068                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11070            ),
11071            _ => local_var_req_builder.query(&[(
11072                "last_updated__gt",
11073                &local_var_str
11074                    .into_iter()
11075                    .map(|p| p.to_string())
11076                    .collect::<Vec<String>>()
11077                    .join(",")
11078                    .to_string(),
11079            )]),
11080        };
11081    }
11082    if let Some(ref local_var_str) = last_updated__gte {
11083        local_var_req_builder = match "multi" {
11084            "multi" => local_var_req_builder.query(
11085                &local_var_str
11086                    .into_iter()
11087                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11089            ),
11090            _ => local_var_req_builder.query(&[(
11091                "last_updated__gte",
11092                &local_var_str
11093                    .into_iter()
11094                    .map(|p| p.to_string())
11095                    .collect::<Vec<String>>()
11096                    .join(",")
11097                    .to_string(),
11098            )]),
11099        };
11100    }
11101    if let Some(ref local_var_str) = last_updated__isnull {
11102        local_var_req_builder =
11103            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
11104    }
11105    if let Some(ref local_var_str) = last_updated__lt {
11106        local_var_req_builder = match "multi" {
11107            "multi" => local_var_req_builder.query(
11108                &local_var_str
11109                    .into_iter()
11110                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11112            ),
11113            _ => local_var_req_builder.query(&[(
11114                "last_updated__lt",
11115                &local_var_str
11116                    .into_iter()
11117                    .map(|p| p.to_string())
11118                    .collect::<Vec<String>>()
11119                    .join(",")
11120                    .to_string(),
11121            )]),
11122        };
11123    }
11124    if let Some(ref local_var_str) = last_updated__lte {
11125        local_var_req_builder = match "multi" {
11126            "multi" => local_var_req_builder.query(
11127                &local_var_str
11128                    .into_iter()
11129                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11131            ),
11132            _ => local_var_req_builder.query(&[(
11133                "last_updated__lte",
11134                &local_var_str
11135                    .into_iter()
11136                    .map(|p| p.to_string())
11137                    .collect::<Vec<String>>()
11138                    .join(",")
11139                    .to_string(),
11140            )]),
11141        };
11142    }
11143    if let Some(ref local_var_str) = last_updated__n {
11144        local_var_req_builder = match "multi" {
11145            "multi" => local_var_req_builder.query(
11146                &local_var_str
11147                    .into_iter()
11148                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11150            ),
11151            _ => local_var_req_builder.query(&[(
11152                "last_updated__n",
11153                &local_var_str
11154                    .into_iter()
11155                    .map(|p| p.to_string())
11156                    .collect::<Vec<String>>()
11157                    .join(",")
11158                    .to_string(),
11159            )]),
11160        };
11161    }
11162    if let Some(ref local_var_str) = limit {
11163        local_var_req_builder =
11164            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11165    }
11166    if let Some(ref local_var_str) = location {
11167        local_var_req_builder = match "multi" {
11168            "multi" => local_var_req_builder.query(
11169                &local_var_str
11170                    .into_iter()
11171                    .map(|p| ("location".to_owned(), p.to_string()))
11172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11173            ),
11174            _ => local_var_req_builder.query(&[(
11175                "location",
11176                &local_var_str
11177                    .into_iter()
11178                    .map(|p| p.to_string())
11179                    .collect::<Vec<String>>()
11180                    .join(",")
11181                    .to_string(),
11182            )]),
11183        };
11184    }
11185    if let Some(ref local_var_str) = location__isnull {
11186        local_var_req_builder =
11187            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
11188    }
11189    if let Some(ref local_var_str) = location__n {
11190        local_var_req_builder = match "multi" {
11191            "multi" => local_var_req_builder.query(
11192                &local_var_str
11193                    .into_iter()
11194                    .map(|p| ("location__n".to_owned(), p.to_string()))
11195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11196            ),
11197            _ => local_var_req_builder.query(&[(
11198                "location__n",
11199                &local_var_str
11200                    .into_iter()
11201                    .map(|p| p.to_string())
11202                    .collect::<Vec<String>>()
11203                    .join(",")
11204                    .to_string(),
11205            )]),
11206        };
11207    }
11208    if let Some(ref local_var_str) = name {
11209        local_var_req_builder = match "multi" {
11210            "multi" => local_var_req_builder.query(
11211                &local_var_str
11212                    .into_iter()
11213                    .map(|p| ("name".to_owned(), p.to_string()))
11214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11215            ),
11216            _ => local_var_req_builder.query(&[(
11217                "name",
11218                &local_var_str
11219                    .into_iter()
11220                    .map(|p| p.to_string())
11221                    .collect::<Vec<String>>()
11222                    .join(",")
11223                    .to_string(),
11224            )]),
11225        };
11226    }
11227    if let Some(ref local_var_str) = name__ic {
11228        local_var_req_builder = match "multi" {
11229            "multi" => local_var_req_builder.query(
11230                &local_var_str
11231                    .into_iter()
11232                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11234            ),
11235            _ => local_var_req_builder.query(&[(
11236                "name__ic",
11237                &local_var_str
11238                    .into_iter()
11239                    .map(|p| p.to_string())
11240                    .collect::<Vec<String>>()
11241                    .join(",")
11242                    .to_string(),
11243            )]),
11244        };
11245    }
11246    if let Some(ref local_var_str) = name__ie {
11247        local_var_req_builder = match "multi" {
11248            "multi" => local_var_req_builder.query(
11249                &local_var_str
11250                    .into_iter()
11251                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11253            ),
11254            _ => local_var_req_builder.query(&[(
11255                "name__ie",
11256                &local_var_str
11257                    .into_iter()
11258                    .map(|p| p.to_string())
11259                    .collect::<Vec<String>>()
11260                    .join(",")
11261                    .to_string(),
11262            )]),
11263        };
11264    }
11265    if let Some(ref local_var_str) = name__iew {
11266        local_var_req_builder = match "multi" {
11267            "multi" => local_var_req_builder.query(
11268                &local_var_str
11269                    .into_iter()
11270                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11272            ),
11273            _ => local_var_req_builder.query(&[(
11274                "name__iew",
11275                &local_var_str
11276                    .into_iter()
11277                    .map(|p| p.to_string())
11278                    .collect::<Vec<String>>()
11279                    .join(",")
11280                    .to_string(),
11281            )]),
11282        };
11283    }
11284    if let Some(ref local_var_str) = name__ire {
11285        local_var_req_builder = match "multi" {
11286            "multi" => local_var_req_builder.query(
11287                &local_var_str
11288                    .into_iter()
11289                    .map(|p| ("name__ire".to_owned(), p.to_string()))
11290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11291            ),
11292            _ => local_var_req_builder.query(&[(
11293                "name__ire",
11294                &local_var_str
11295                    .into_iter()
11296                    .map(|p| p.to_string())
11297                    .collect::<Vec<String>>()
11298                    .join(",")
11299                    .to_string(),
11300            )]),
11301        };
11302    }
11303    if let Some(ref local_var_str) = name__isw {
11304        local_var_req_builder = match "multi" {
11305            "multi" => local_var_req_builder.query(
11306                &local_var_str
11307                    .into_iter()
11308                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11310            ),
11311            _ => local_var_req_builder.query(&[(
11312                "name__isw",
11313                &local_var_str
11314                    .into_iter()
11315                    .map(|p| p.to_string())
11316                    .collect::<Vec<String>>()
11317                    .join(",")
11318                    .to_string(),
11319            )]),
11320        };
11321    }
11322    if let Some(ref local_var_str) = name__n {
11323        local_var_req_builder = match "multi" {
11324            "multi" => local_var_req_builder.query(
11325                &local_var_str
11326                    .into_iter()
11327                    .map(|p| ("name__n".to_owned(), p.to_string()))
11328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11329            ),
11330            _ => local_var_req_builder.query(&[(
11331                "name__n",
11332                &local_var_str
11333                    .into_iter()
11334                    .map(|p| p.to_string())
11335                    .collect::<Vec<String>>()
11336                    .join(",")
11337                    .to_string(),
11338            )]),
11339        };
11340    }
11341    if let Some(ref local_var_str) = name__nic {
11342        local_var_req_builder = match "multi" {
11343            "multi" => local_var_req_builder.query(
11344                &local_var_str
11345                    .into_iter()
11346                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11348            ),
11349            _ => local_var_req_builder.query(&[(
11350                "name__nic",
11351                &local_var_str
11352                    .into_iter()
11353                    .map(|p| p.to_string())
11354                    .collect::<Vec<String>>()
11355                    .join(",")
11356                    .to_string(),
11357            )]),
11358        };
11359    }
11360    if let Some(ref local_var_str) = name__nie {
11361        local_var_req_builder = match "multi" {
11362            "multi" => local_var_req_builder.query(
11363                &local_var_str
11364                    .into_iter()
11365                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11367            ),
11368            _ => local_var_req_builder.query(&[(
11369                "name__nie",
11370                &local_var_str
11371                    .into_iter()
11372                    .map(|p| p.to_string())
11373                    .collect::<Vec<String>>()
11374                    .join(",")
11375                    .to_string(),
11376            )]),
11377        };
11378    }
11379    if let Some(ref local_var_str) = name__niew {
11380        local_var_req_builder = match "multi" {
11381            "multi" => local_var_req_builder.query(
11382                &local_var_str
11383                    .into_iter()
11384                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11386            ),
11387            _ => local_var_req_builder.query(&[(
11388                "name__niew",
11389                &local_var_str
11390                    .into_iter()
11391                    .map(|p| p.to_string())
11392                    .collect::<Vec<String>>()
11393                    .join(",")
11394                    .to_string(),
11395            )]),
11396        };
11397    }
11398    if let Some(ref local_var_str) = name__nire {
11399        local_var_req_builder = match "multi" {
11400            "multi" => local_var_req_builder.query(
11401                &local_var_str
11402                    .into_iter()
11403                    .map(|p| ("name__nire".to_owned(), p.to_string()))
11404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11405            ),
11406            _ => local_var_req_builder.query(&[(
11407                "name__nire",
11408                &local_var_str
11409                    .into_iter()
11410                    .map(|p| p.to_string())
11411                    .collect::<Vec<String>>()
11412                    .join(",")
11413                    .to_string(),
11414            )]),
11415        };
11416    }
11417    if let Some(ref local_var_str) = name__nisw {
11418        local_var_req_builder = match "multi" {
11419            "multi" => local_var_req_builder.query(
11420                &local_var_str
11421                    .into_iter()
11422                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11424            ),
11425            _ => local_var_req_builder.query(&[(
11426                "name__nisw",
11427                &local_var_str
11428                    .into_iter()
11429                    .map(|p| p.to_string())
11430                    .collect::<Vec<String>>()
11431                    .join(",")
11432                    .to_string(),
11433            )]),
11434        };
11435    }
11436    if let Some(ref local_var_str) = name__nre {
11437        local_var_req_builder = match "multi" {
11438            "multi" => local_var_req_builder.query(
11439                &local_var_str
11440                    .into_iter()
11441                    .map(|p| ("name__nre".to_owned(), p.to_string()))
11442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11443            ),
11444            _ => local_var_req_builder.query(&[(
11445                "name__nre",
11446                &local_var_str
11447                    .into_iter()
11448                    .map(|p| p.to_string())
11449                    .collect::<Vec<String>>()
11450                    .join(",")
11451                    .to_string(),
11452            )]),
11453        };
11454    }
11455    if let Some(ref local_var_str) = name__re {
11456        local_var_req_builder = match "multi" {
11457            "multi" => local_var_req_builder.query(
11458                &local_var_str
11459                    .into_iter()
11460                    .map(|p| ("name__re".to_owned(), p.to_string()))
11461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11462            ),
11463            _ => local_var_req_builder.query(&[(
11464                "name__re",
11465                &local_var_str
11466                    .into_iter()
11467                    .map(|p| p.to_string())
11468                    .collect::<Vec<String>>()
11469                    .join(",")
11470                    .to_string(),
11471            )]),
11472        };
11473    }
11474    if let Some(ref local_var_str) = noc_contact {
11475        local_var_req_builder = match "multi" {
11476            "multi" => local_var_req_builder.query(
11477                &local_var_str
11478                    .into_iter()
11479                    .map(|p| ("noc_contact".to_owned(), p.to_string()))
11480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11481            ),
11482            _ => local_var_req_builder.query(&[(
11483                "noc_contact",
11484                &local_var_str
11485                    .into_iter()
11486                    .map(|p| p.to_string())
11487                    .collect::<Vec<String>>()
11488                    .join(",")
11489                    .to_string(),
11490            )]),
11491        };
11492    }
11493    if let Some(ref local_var_str) = noc_contact__ic {
11494        local_var_req_builder = match "multi" {
11495            "multi" => local_var_req_builder.query(
11496                &local_var_str
11497                    .into_iter()
11498                    .map(|p| ("noc_contact__ic".to_owned(), p.to_string()))
11499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11500            ),
11501            _ => local_var_req_builder.query(&[(
11502                "noc_contact__ic",
11503                &local_var_str
11504                    .into_iter()
11505                    .map(|p| p.to_string())
11506                    .collect::<Vec<String>>()
11507                    .join(",")
11508                    .to_string(),
11509            )]),
11510        };
11511    }
11512    if let Some(ref local_var_str) = noc_contact__ie {
11513        local_var_req_builder = match "multi" {
11514            "multi" => local_var_req_builder.query(
11515                &local_var_str
11516                    .into_iter()
11517                    .map(|p| ("noc_contact__ie".to_owned(), p.to_string()))
11518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11519            ),
11520            _ => local_var_req_builder.query(&[(
11521                "noc_contact__ie",
11522                &local_var_str
11523                    .into_iter()
11524                    .map(|p| p.to_string())
11525                    .collect::<Vec<String>>()
11526                    .join(",")
11527                    .to_string(),
11528            )]),
11529        };
11530    }
11531    if let Some(ref local_var_str) = noc_contact__iew {
11532        local_var_req_builder = match "multi" {
11533            "multi" => local_var_req_builder.query(
11534                &local_var_str
11535                    .into_iter()
11536                    .map(|p| ("noc_contact__iew".to_owned(), p.to_string()))
11537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11538            ),
11539            _ => local_var_req_builder.query(&[(
11540                "noc_contact__iew",
11541                &local_var_str
11542                    .into_iter()
11543                    .map(|p| p.to_string())
11544                    .collect::<Vec<String>>()
11545                    .join(",")
11546                    .to_string(),
11547            )]),
11548        };
11549    }
11550    if let Some(ref local_var_str) = noc_contact__ire {
11551        local_var_req_builder = match "multi" {
11552            "multi" => local_var_req_builder.query(
11553                &local_var_str
11554                    .into_iter()
11555                    .map(|p| ("noc_contact__ire".to_owned(), p.to_string()))
11556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11557            ),
11558            _ => local_var_req_builder.query(&[(
11559                "noc_contact__ire",
11560                &local_var_str
11561                    .into_iter()
11562                    .map(|p| p.to_string())
11563                    .collect::<Vec<String>>()
11564                    .join(",")
11565                    .to_string(),
11566            )]),
11567        };
11568    }
11569    if let Some(ref local_var_str) = noc_contact__isw {
11570        local_var_req_builder = match "multi" {
11571            "multi" => local_var_req_builder.query(
11572                &local_var_str
11573                    .into_iter()
11574                    .map(|p| ("noc_contact__isw".to_owned(), p.to_string()))
11575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11576            ),
11577            _ => local_var_req_builder.query(&[(
11578                "noc_contact__isw",
11579                &local_var_str
11580                    .into_iter()
11581                    .map(|p| p.to_string())
11582                    .collect::<Vec<String>>()
11583                    .join(",")
11584                    .to_string(),
11585            )]),
11586        };
11587    }
11588    if let Some(ref local_var_str) = noc_contact__n {
11589        local_var_req_builder = match "multi" {
11590            "multi" => local_var_req_builder.query(
11591                &local_var_str
11592                    .into_iter()
11593                    .map(|p| ("noc_contact__n".to_owned(), p.to_string()))
11594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11595            ),
11596            _ => local_var_req_builder.query(&[(
11597                "noc_contact__n",
11598                &local_var_str
11599                    .into_iter()
11600                    .map(|p| p.to_string())
11601                    .collect::<Vec<String>>()
11602                    .join(",")
11603                    .to_string(),
11604            )]),
11605        };
11606    }
11607    if let Some(ref local_var_str) = noc_contact__nic {
11608        local_var_req_builder = match "multi" {
11609            "multi" => local_var_req_builder.query(
11610                &local_var_str
11611                    .into_iter()
11612                    .map(|p| ("noc_contact__nic".to_owned(), p.to_string()))
11613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11614            ),
11615            _ => local_var_req_builder.query(&[(
11616                "noc_contact__nic",
11617                &local_var_str
11618                    .into_iter()
11619                    .map(|p| p.to_string())
11620                    .collect::<Vec<String>>()
11621                    .join(",")
11622                    .to_string(),
11623            )]),
11624        };
11625    }
11626    if let Some(ref local_var_str) = noc_contact__nie {
11627        local_var_req_builder = match "multi" {
11628            "multi" => local_var_req_builder.query(
11629                &local_var_str
11630                    .into_iter()
11631                    .map(|p| ("noc_contact__nie".to_owned(), p.to_string()))
11632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11633            ),
11634            _ => local_var_req_builder.query(&[(
11635                "noc_contact__nie",
11636                &local_var_str
11637                    .into_iter()
11638                    .map(|p| p.to_string())
11639                    .collect::<Vec<String>>()
11640                    .join(",")
11641                    .to_string(),
11642            )]),
11643        };
11644    }
11645    if let Some(ref local_var_str) = noc_contact__niew {
11646        local_var_req_builder = match "multi" {
11647            "multi" => local_var_req_builder.query(
11648                &local_var_str
11649                    .into_iter()
11650                    .map(|p| ("noc_contact__niew".to_owned(), p.to_string()))
11651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11652            ),
11653            _ => local_var_req_builder.query(&[(
11654                "noc_contact__niew",
11655                &local_var_str
11656                    .into_iter()
11657                    .map(|p| p.to_string())
11658                    .collect::<Vec<String>>()
11659                    .join(",")
11660                    .to_string(),
11661            )]),
11662        };
11663    }
11664    if let Some(ref local_var_str) = noc_contact__nire {
11665        local_var_req_builder = match "multi" {
11666            "multi" => local_var_req_builder.query(
11667                &local_var_str
11668                    .into_iter()
11669                    .map(|p| ("noc_contact__nire".to_owned(), p.to_string()))
11670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11671            ),
11672            _ => local_var_req_builder.query(&[(
11673                "noc_contact__nire",
11674                &local_var_str
11675                    .into_iter()
11676                    .map(|p| p.to_string())
11677                    .collect::<Vec<String>>()
11678                    .join(",")
11679                    .to_string(),
11680            )]),
11681        };
11682    }
11683    if let Some(ref local_var_str) = noc_contact__nisw {
11684        local_var_req_builder = match "multi" {
11685            "multi" => local_var_req_builder.query(
11686                &local_var_str
11687                    .into_iter()
11688                    .map(|p| ("noc_contact__nisw".to_owned(), p.to_string()))
11689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11690            ),
11691            _ => local_var_req_builder.query(&[(
11692                "noc_contact__nisw",
11693                &local_var_str
11694                    .into_iter()
11695                    .map(|p| p.to_string())
11696                    .collect::<Vec<String>>()
11697                    .join(",")
11698                    .to_string(),
11699            )]),
11700        };
11701    }
11702    if let Some(ref local_var_str) = noc_contact__nre {
11703        local_var_req_builder = match "multi" {
11704            "multi" => local_var_req_builder.query(
11705                &local_var_str
11706                    .into_iter()
11707                    .map(|p| ("noc_contact__nre".to_owned(), p.to_string()))
11708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11709            ),
11710            _ => local_var_req_builder.query(&[(
11711                "noc_contact__nre",
11712                &local_var_str
11713                    .into_iter()
11714                    .map(|p| p.to_string())
11715                    .collect::<Vec<String>>()
11716                    .join(",")
11717                    .to_string(),
11718            )]),
11719        };
11720    }
11721    if let Some(ref local_var_str) = noc_contact__re {
11722        local_var_req_builder = match "multi" {
11723            "multi" => local_var_req_builder.query(
11724                &local_var_str
11725                    .into_iter()
11726                    .map(|p| ("noc_contact__re".to_owned(), p.to_string()))
11727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11728            ),
11729            _ => local_var_req_builder.query(&[(
11730                "noc_contact__re",
11731                &local_var_str
11732                    .into_iter()
11733                    .map(|p| p.to_string())
11734                    .collect::<Vec<String>>()
11735                    .join(",")
11736                    .to_string(),
11737            )]),
11738        };
11739    }
11740    if let Some(ref local_var_str) = offset {
11741        local_var_req_builder =
11742            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11743    }
11744    if let Some(ref local_var_str) = portal_url {
11745        local_var_req_builder = match "multi" {
11746            "multi" => local_var_req_builder.query(
11747                &local_var_str
11748                    .into_iter()
11749                    .map(|p| ("portal_url".to_owned(), p.to_string()))
11750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11751            ),
11752            _ => local_var_req_builder.query(&[(
11753                "portal_url",
11754                &local_var_str
11755                    .into_iter()
11756                    .map(|p| p.to_string())
11757                    .collect::<Vec<String>>()
11758                    .join(",")
11759                    .to_string(),
11760            )]),
11761        };
11762    }
11763    if let Some(ref local_var_str) = portal_url__ic {
11764        local_var_req_builder = match "multi" {
11765            "multi" => local_var_req_builder.query(
11766                &local_var_str
11767                    .into_iter()
11768                    .map(|p| ("portal_url__ic".to_owned(), p.to_string()))
11769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11770            ),
11771            _ => local_var_req_builder.query(&[(
11772                "portal_url__ic",
11773                &local_var_str
11774                    .into_iter()
11775                    .map(|p| p.to_string())
11776                    .collect::<Vec<String>>()
11777                    .join(",")
11778                    .to_string(),
11779            )]),
11780        };
11781    }
11782    if let Some(ref local_var_str) = portal_url__ie {
11783        local_var_req_builder = match "multi" {
11784            "multi" => local_var_req_builder.query(
11785                &local_var_str
11786                    .into_iter()
11787                    .map(|p| ("portal_url__ie".to_owned(), p.to_string()))
11788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11789            ),
11790            _ => local_var_req_builder.query(&[(
11791                "portal_url__ie",
11792                &local_var_str
11793                    .into_iter()
11794                    .map(|p| p.to_string())
11795                    .collect::<Vec<String>>()
11796                    .join(",")
11797                    .to_string(),
11798            )]),
11799        };
11800    }
11801    if let Some(ref local_var_str) = portal_url__iew {
11802        local_var_req_builder = match "multi" {
11803            "multi" => local_var_req_builder.query(
11804                &local_var_str
11805                    .into_iter()
11806                    .map(|p| ("portal_url__iew".to_owned(), p.to_string()))
11807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11808            ),
11809            _ => local_var_req_builder.query(&[(
11810                "portal_url__iew",
11811                &local_var_str
11812                    .into_iter()
11813                    .map(|p| p.to_string())
11814                    .collect::<Vec<String>>()
11815                    .join(",")
11816                    .to_string(),
11817            )]),
11818        };
11819    }
11820    if let Some(ref local_var_str) = portal_url__ire {
11821        local_var_req_builder = match "multi" {
11822            "multi" => local_var_req_builder.query(
11823                &local_var_str
11824                    .into_iter()
11825                    .map(|p| ("portal_url__ire".to_owned(), p.to_string()))
11826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11827            ),
11828            _ => local_var_req_builder.query(&[(
11829                "portal_url__ire",
11830                &local_var_str
11831                    .into_iter()
11832                    .map(|p| p.to_string())
11833                    .collect::<Vec<String>>()
11834                    .join(",")
11835                    .to_string(),
11836            )]),
11837        };
11838    }
11839    if let Some(ref local_var_str) = portal_url__isw {
11840        local_var_req_builder = match "multi" {
11841            "multi" => local_var_req_builder.query(
11842                &local_var_str
11843                    .into_iter()
11844                    .map(|p| ("portal_url__isw".to_owned(), p.to_string()))
11845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11846            ),
11847            _ => local_var_req_builder.query(&[(
11848                "portal_url__isw",
11849                &local_var_str
11850                    .into_iter()
11851                    .map(|p| p.to_string())
11852                    .collect::<Vec<String>>()
11853                    .join(",")
11854                    .to_string(),
11855            )]),
11856        };
11857    }
11858    if let Some(ref local_var_str) = portal_url__n {
11859        local_var_req_builder = match "multi" {
11860            "multi" => local_var_req_builder.query(
11861                &local_var_str
11862                    .into_iter()
11863                    .map(|p| ("portal_url__n".to_owned(), p.to_string()))
11864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11865            ),
11866            _ => local_var_req_builder.query(&[(
11867                "portal_url__n",
11868                &local_var_str
11869                    .into_iter()
11870                    .map(|p| p.to_string())
11871                    .collect::<Vec<String>>()
11872                    .join(",")
11873                    .to_string(),
11874            )]),
11875        };
11876    }
11877    if let Some(ref local_var_str) = portal_url__nic {
11878        local_var_req_builder = match "multi" {
11879            "multi" => local_var_req_builder.query(
11880                &local_var_str
11881                    .into_iter()
11882                    .map(|p| ("portal_url__nic".to_owned(), p.to_string()))
11883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11884            ),
11885            _ => local_var_req_builder.query(&[(
11886                "portal_url__nic",
11887                &local_var_str
11888                    .into_iter()
11889                    .map(|p| p.to_string())
11890                    .collect::<Vec<String>>()
11891                    .join(",")
11892                    .to_string(),
11893            )]),
11894        };
11895    }
11896    if let Some(ref local_var_str) = portal_url__nie {
11897        local_var_req_builder = match "multi" {
11898            "multi" => local_var_req_builder.query(
11899                &local_var_str
11900                    .into_iter()
11901                    .map(|p| ("portal_url__nie".to_owned(), p.to_string()))
11902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11903            ),
11904            _ => local_var_req_builder.query(&[(
11905                "portal_url__nie",
11906                &local_var_str
11907                    .into_iter()
11908                    .map(|p| p.to_string())
11909                    .collect::<Vec<String>>()
11910                    .join(",")
11911                    .to_string(),
11912            )]),
11913        };
11914    }
11915    if let Some(ref local_var_str) = portal_url__niew {
11916        local_var_req_builder = match "multi" {
11917            "multi" => local_var_req_builder.query(
11918                &local_var_str
11919                    .into_iter()
11920                    .map(|p| ("portal_url__niew".to_owned(), p.to_string()))
11921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11922            ),
11923            _ => local_var_req_builder.query(&[(
11924                "portal_url__niew",
11925                &local_var_str
11926                    .into_iter()
11927                    .map(|p| p.to_string())
11928                    .collect::<Vec<String>>()
11929                    .join(",")
11930                    .to_string(),
11931            )]),
11932        };
11933    }
11934    if let Some(ref local_var_str) = portal_url__nire {
11935        local_var_req_builder = match "multi" {
11936            "multi" => local_var_req_builder.query(
11937                &local_var_str
11938                    .into_iter()
11939                    .map(|p| ("portal_url__nire".to_owned(), p.to_string()))
11940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11941            ),
11942            _ => local_var_req_builder.query(&[(
11943                "portal_url__nire",
11944                &local_var_str
11945                    .into_iter()
11946                    .map(|p| p.to_string())
11947                    .collect::<Vec<String>>()
11948                    .join(",")
11949                    .to_string(),
11950            )]),
11951        };
11952    }
11953    if let Some(ref local_var_str) = portal_url__nisw {
11954        local_var_req_builder = match "multi" {
11955            "multi" => local_var_req_builder.query(
11956                &local_var_str
11957                    .into_iter()
11958                    .map(|p| ("portal_url__nisw".to_owned(), p.to_string()))
11959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11960            ),
11961            _ => local_var_req_builder.query(&[(
11962                "portal_url__nisw",
11963                &local_var_str
11964                    .into_iter()
11965                    .map(|p| p.to_string())
11966                    .collect::<Vec<String>>()
11967                    .join(",")
11968                    .to_string(),
11969            )]),
11970        };
11971    }
11972    if let Some(ref local_var_str) = portal_url__nre {
11973        local_var_req_builder = match "multi" {
11974            "multi" => local_var_req_builder.query(
11975                &local_var_str
11976                    .into_iter()
11977                    .map(|p| ("portal_url__nre".to_owned(), p.to_string()))
11978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11979            ),
11980            _ => local_var_req_builder.query(&[(
11981                "portal_url__nre",
11982                &local_var_str
11983                    .into_iter()
11984                    .map(|p| p.to_string())
11985                    .collect::<Vec<String>>()
11986                    .join(",")
11987                    .to_string(),
11988            )]),
11989        };
11990    }
11991    if let Some(ref local_var_str) = portal_url__re {
11992        local_var_req_builder = match "multi" {
11993            "multi" => local_var_req_builder.query(
11994                &local_var_str
11995                    .into_iter()
11996                    .map(|p| ("portal_url__re".to_owned(), p.to_string()))
11997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11998            ),
11999            _ => local_var_req_builder.query(&[(
12000                "portal_url__re",
12001                &local_var_str
12002                    .into_iter()
12003                    .map(|p| p.to_string())
12004                    .collect::<Vec<String>>()
12005                    .join(",")
12006                    .to_string(),
12007            )]),
12008        };
12009    }
12010    if let Some(ref local_var_str) = provider_networks {
12011        local_var_req_builder = match "multi" {
12012            "multi" => local_var_req_builder.query(
12013                &local_var_str
12014                    .into_iter()
12015                    .map(|p| ("provider_networks".to_owned(), p.to_string()))
12016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12017            ),
12018            _ => local_var_req_builder.query(&[(
12019                "provider_networks",
12020                &local_var_str
12021                    .into_iter()
12022                    .map(|p| p.to_string())
12023                    .collect::<Vec<String>>()
12024                    .join(",")
12025                    .to_string(),
12026            )]),
12027        };
12028    }
12029    if let Some(ref local_var_str) = provider_networks__isnull {
12030        local_var_req_builder = local_var_req_builder
12031            .query(&[("provider_networks__isnull", &local_var_str.to_string())]);
12032    }
12033    if let Some(ref local_var_str) = provider_networks__n {
12034        local_var_req_builder = match "multi" {
12035            "multi" => local_var_req_builder.query(
12036                &local_var_str
12037                    .into_iter()
12038                    .map(|p| ("provider_networks__n".to_owned(), p.to_string()))
12039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12040            ),
12041            _ => local_var_req_builder.query(&[(
12042                "provider_networks__n",
12043                &local_var_str
12044                    .into_iter()
12045                    .map(|p| p.to_string())
12046                    .collect::<Vec<String>>()
12047                    .join(",")
12048                    .to_string(),
12049            )]),
12050        };
12051    }
12052    if let Some(ref local_var_str) = q {
12053        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12054    }
12055    if let Some(ref local_var_str) = sort {
12056        local_var_req_builder =
12057            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
12058    }
12059    if let Some(ref local_var_str) = tags {
12060        local_var_req_builder = match "multi" {
12061            "multi" => local_var_req_builder.query(
12062                &local_var_str
12063                    .into_iter()
12064                    .map(|p| ("tags".to_owned(), p.to_string()))
12065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12066            ),
12067            _ => local_var_req_builder.query(&[(
12068                "tags",
12069                &local_var_str
12070                    .into_iter()
12071                    .map(|p| p.to_string())
12072                    .collect::<Vec<String>>()
12073                    .join(",")
12074                    .to_string(),
12075            )]),
12076        };
12077    }
12078    if let Some(ref local_var_str) = tags__isnull {
12079        local_var_req_builder =
12080            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
12081    }
12082    if let Some(ref local_var_str) = tags__n {
12083        local_var_req_builder = match "multi" {
12084            "multi" => local_var_req_builder.query(
12085                &local_var_str
12086                    .into_iter()
12087                    .map(|p| ("tags__n".to_owned(), p.to_string()))
12088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12089            ),
12090            _ => local_var_req_builder.query(&[(
12091                "tags__n",
12092                &local_var_str
12093                    .into_iter()
12094                    .map(|p| p.to_string())
12095                    .collect::<Vec<String>>()
12096                    .join(",")
12097                    .to_string(),
12098            )]),
12099        };
12100    }
12101    if let Some(ref local_var_str) = teams {
12102        local_var_req_builder = match "multi" {
12103            "multi" => local_var_req_builder.query(
12104                &local_var_str
12105                    .into_iter()
12106                    .map(|p| ("teams".to_owned(), p.to_string()))
12107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12108            ),
12109            _ => local_var_req_builder.query(&[(
12110                "teams",
12111                &local_var_str
12112                    .into_iter()
12113                    .map(|p| p.to_string())
12114                    .collect::<Vec<String>>()
12115                    .join(",")
12116                    .to_string(),
12117            )]),
12118        };
12119    }
12120    if let Some(ref local_var_str) = teams__isnull {
12121        local_var_req_builder =
12122            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
12123    }
12124    if let Some(ref local_var_str) = teams__n {
12125        local_var_req_builder = match "multi" {
12126            "multi" => local_var_req_builder.query(
12127                &local_var_str
12128                    .into_iter()
12129                    .map(|p| ("teams__n".to_owned(), p.to_string()))
12130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12131            ),
12132            _ => local_var_req_builder.query(&[(
12133                "teams__n",
12134                &local_var_str
12135                    .into_iter()
12136                    .map(|p| p.to_string())
12137                    .collect::<Vec<String>>()
12138                    .join(",")
12139                    .to_string(),
12140            )]),
12141        };
12142    }
12143    if let Some(ref local_var_str) = depth {
12144        local_var_req_builder =
12145            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12146    }
12147    if let Some(ref local_var_str) = exclude_m2m {
12148        local_var_req_builder =
12149            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12150    }
12151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12152        local_var_req_builder =
12153            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12154    }
12155    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12156        let local_var_key = local_var_apikey.key.clone();
12157        let local_var_value = match local_var_apikey.prefix {
12158            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12159            None => local_var_key,
12160        };
12161        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12162    };
12163
12164    let local_var_req = local_var_req_builder.build()?;
12165    let local_var_resp = local_var_client.execute(local_var_req).await?;
12166
12167    let local_var_status = local_var_resp.status();
12168    let local_var_content = local_var_resp.text().await?;
12169
12170    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12171        serde_json::from_str(&local_var_content).map_err(Error::from)
12172    } else {
12173        let local_var_entity: Option<CircuitsProvidersListError> =
12174            serde_json::from_str(&local_var_content).ok();
12175        let local_var_error = ResponseContent {
12176            status: local_var_status,
12177            content: local_var_content,
12178            entity: local_var_entity,
12179        };
12180        Err(Error::ResponseError(local_var_error))
12181    }
12182}
12183
12184/// API methods for returning or creating notes on an object.
12185pub async fn circuits_providers_notes_create(
12186    configuration: &configuration::Configuration,
12187    id: &str,
12188    note_input_request: crate::models::NoteInputRequest,
12189    format: Option<&str>,
12190) -> Result<crate::models::Note, Error<CircuitsProvidersNotesCreateError>> {
12191    let local_var_configuration = configuration;
12192
12193    let local_var_client = &local_var_configuration.client;
12194
12195    let local_var_uri_str = format!(
12196        "{}/circuits/providers/{id}/notes/",
12197        local_var_configuration.base_path,
12198        id = crate::apis::urlencode(id)
12199    );
12200    let mut local_var_req_builder =
12201        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
12202
12203    if let Some(ref local_var_str) = format {
12204        local_var_req_builder =
12205            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12206    }
12207    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12208        local_var_req_builder =
12209            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12210    }
12211    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12212        let local_var_key = local_var_apikey.key.clone();
12213        let local_var_value = match local_var_apikey.prefix {
12214            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12215            None => local_var_key,
12216        };
12217        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12218    };
12219    local_var_req_builder = local_var_req_builder.json(&note_input_request);
12220
12221    let local_var_req = local_var_req_builder.build()?;
12222    let local_var_resp = local_var_client.execute(local_var_req).await?;
12223
12224    let local_var_status = local_var_resp.status();
12225    let local_var_content = local_var_resp.text().await?;
12226
12227    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12228        serde_json::from_str(&local_var_content).map_err(Error::from)
12229    } else {
12230        let local_var_entity: Option<CircuitsProvidersNotesCreateError> =
12231            serde_json::from_str(&local_var_content).ok();
12232        let local_var_error = ResponseContent {
12233            status: local_var_status,
12234            content: local_var_content,
12235            entity: local_var_entity,
12236        };
12237        Err(Error::ResponseError(local_var_error))
12238    }
12239}
12240
12241/// API methods for returning or creating notes on an object.
12242pub async fn circuits_providers_notes_list(
12243    configuration: &configuration::Configuration,
12244    id: &str,
12245    format: Option<&str>,
12246    limit: Option<i32>,
12247    offset: Option<i32>,
12248    depth: Option<i32>,
12249    exclude_m2m: Option<bool>,
12250) -> Result<crate::models::PaginatedNoteList, Error<CircuitsProvidersNotesListError>> {
12251    let local_var_configuration = configuration;
12252
12253    let local_var_client = &local_var_configuration.client;
12254
12255    let local_var_uri_str = format!(
12256        "{}/circuits/providers/{id}/notes/",
12257        local_var_configuration.base_path,
12258        id = crate::apis::urlencode(id)
12259    );
12260    let mut local_var_req_builder =
12261        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12262
12263    if let Some(ref local_var_str) = format {
12264        local_var_req_builder =
12265            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12266    }
12267    if let Some(ref local_var_str) = limit {
12268        local_var_req_builder =
12269            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12270    }
12271    if let Some(ref local_var_str) = offset {
12272        local_var_req_builder =
12273            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12274    }
12275    if let Some(ref local_var_str) = depth {
12276        local_var_req_builder =
12277            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12278    }
12279    if let Some(ref local_var_str) = exclude_m2m {
12280        local_var_req_builder =
12281            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12282    }
12283    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12284        local_var_req_builder =
12285            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12286    }
12287    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12288        let local_var_key = local_var_apikey.key.clone();
12289        let local_var_value = match local_var_apikey.prefix {
12290            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12291            None => local_var_key,
12292        };
12293        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12294    };
12295
12296    let local_var_req = local_var_req_builder.build()?;
12297    let local_var_resp = local_var_client.execute(local_var_req).await?;
12298
12299    let local_var_status = local_var_resp.status();
12300    let local_var_content = local_var_resp.text().await?;
12301
12302    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12303        serde_json::from_str(&local_var_content).map_err(Error::from)
12304    } else {
12305        let local_var_entity: Option<CircuitsProvidersNotesListError> =
12306            serde_json::from_str(&local_var_content).ok();
12307        let local_var_error = ResponseContent {
12308            status: local_var_status,
12309            content: local_var_content,
12310            entity: local_var_entity,
12311        };
12312        Err(Error::ResponseError(local_var_error))
12313    }
12314}
12315
12316/// Partial update a provider object.
12317pub async fn circuits_providers_partial_update(
12318    configuration: &configuration::Configuration,
12319    id: &str,
12320    format: Option<&str>,
12321    patched_provider_request: Option<crate::models::PatchedProviderRequest>,
12322) -> Result<crate::models::Provider, Error<CircuitsProvidersPartialUpdateError>> {
12323    let local_var_configuration = configuration;
12324
12325    let local_var_client = &local_var_configuration.client;
12326
12327    let local_var_uri_str = format!(
12328        "{}/circuits/providers/{id}/",
12329        local_var_configuration.base_path,
12330        id = crate::apis::urlencode(id)
12331    );
12332    let mut local_var_req_builder =
12333        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12334
12335    if let Some(ref local_var_str) = format {
12336        local_var_req_builder =
12337            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12338    }
12339    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12340        local_var_req_builder =
12341            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12342    }
12343    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12344        let local_var_key = local_var_apikey.key.clone();
12345        let local_var_value = match local_var_apikey.prefix {
12346            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12347            None => local_var_key,
12348        };
12349        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12350    };
12351    local_var_req_builder = local_var_req_builder.json(&patched_provider_request);
12352
12353    let local_var_req = local_var_req_builder.build()?;
12354    let local_var_resp = local_var_client.execute(local_var_req).await?;
12355
12356    let local_var_status = local_var_resp.status();
12357    let local_var_content = local_var_resp.text().await?;
12358
12359    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12360        serde_json::from_str(&local_var_content).map_err(Error::from)
12361    } else {
12362        let local_var_entity: Option<CircuitsProvidersPartialUpdateError> =
12363            serde_json::from_str(&local_var_content).ok();
12364        let local_var_error = ResponseContent {
12365            status: local_var_status,
12366            content: local_var_content,
12367            entity: local_var_entity,
12368        };
12369        Err(Error::ResponseError(local_var_error))
12370    }
12371}
12372
12373/// Retrieve a provider object.
12374pub async fn circuits_providers_retrieve(
12375    configuration: &configuration::Configuration,
12376    id: &str,
12377    format: Option<&str>,
12378    depth: Option<i32>,
12379    exclude_m2m: Option<bool>,
12380) -> Result<crate::models::Provider, Error<CircuitsProvidersRetrieveError>> {
12381    let local_var_configuration = configuration;
12382
12383    let local_var_client = &local_var_configuration.client;
12384
12385    let local_var_uri_str = format!(
12386        "{}/circuits/providers/{id}/",
12387        local_var_configuration.base_path,
12388        id = crate::apis::urlencode(id)
12389    );
12390    let mut local_var_req_builder =
12391        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12392
12393    if let Some(ref local_var_str) = format {
12394        local_var_req_builder =
12395            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12396    }
12397    if let Some(ref local_var_str) = depth {
12398        local_var_req_builder =
12399            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12400    }
12401    if let Some(ref local_var_str) = exclude_m2m {
12402        local_var_req_builder =
12403            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12404    }
12405    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12406        local_var_req_builder =
12407            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12408    }
12409    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12410        let local_var_key = local_var_apikey.key.clone();
12411        let local_var_value = match local_var_apikey.prefix {
12412            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12413            None => local_var_key,
12414        };
12415        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12416    };
12417
12418    let local_var_req = local_var_req_builder.build()?;
12419    let local_var_resp = local_var_client.execute(local_var_req).await?;
12420
12421    let local_var_status = local_var_resp.status();
12422    let local_var_content = local_var_resp.text().await?;
12423
12424    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12425        serde_json::from_str(&local_var_content).map_err(Error::from)
12426    } else {
12427        let local_var_entity: Option<CircuitsProvidersRetrieveError> =
12428            serde_json::from_str(&local_var_content).ok();
12429        let local_var_error = ResponseContent {
12430            status: local_var_status,
12431            content: local_var_content,
12432            entity: local_var_entity,
12433        };
12434        Err(Error::ResponseError(local_var_error))
12435    }
12436}
12437
12438/// Update a provider object.
12439pub async fn circuits_providers_update(
12440    configuration: &configuration::Configuration,
12441    id: &str,
12442    provider_request: crate::models::ProviderRequest,
12443    format: Option<&str>,
12444) -> Result<crate::models::Provider, Error<CircuitsProvidersUpdateError>> {
12445    let local_var_configuration = configuration;
12446
12447    let local_var_client = &local_var_configuration.client;
12448
12449    let local_var_uri_str = format!(
12450        "{}/circuits/providers/{id}/",
12451        local_var_configuration.base_path,
12452        id = crate::apis::urlencode(id)
12453    );
12454    let mut local_var_req_builder =
12455        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12456
12457    if let Some(ref local_var_str) = format {
12458        local_var_req_builder =
12459            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12460    }
12461    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12462        local_var_req_builder =
12463            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12464    }
12465    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12466        let local_var_key = local_var_apikey.key.clone();
12467        let local_var_value = match local_var_apikey.prefix {
12468            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12469            None => local_var_key,
12470        };
12471        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12472    };
12473    local_var_req_builder = local_var_req_builder.json(&provider_request);
12474
12475    let local_var_req = local_var_req_builder.build()?;
12476    let local_var_resp = local_var_client.execute(local_var_req).await?;
12477
12478    let local_var_status = local_var_resp.status();
12479    let local_var_content = local_var_resp.text().await?;
12480
12481    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12482        serde_json::from_str(&local_var_content).map_err(Error::from)
12483    } else {
12484        let local_var_entity: Option<CircuitsProvidersUpdateError> =
12485            serde_json::from_str(&local_var_content).ok();
12486        let local_var_error = ResponseContent {
12487            status: local_var_status,
12488            content: local_var_content,
12489            entity: local_var_entity,
12490        };
12491        Err(Error::ResponseError(local_var_error))
12492    }
12493}
nautobot_openapi/apis/circuits_api.rs

nautobot_openapi/apis/
circuits_api.rs
