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

nautobot_openapi/apis/
data_validation_api.rs
