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

nautobot_openapi/apis/
cloud_api.rs
