clientapi_pve/apis/
cluster_firewall_api.rs

1/*
2 * Proxmox Virtual Environment API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pve.proxmox.com/pve-docs/api-viewer/ for the upstream documentation.
5 *
6 * The version of the OpenAPI document: 9.x
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`cluster_firewall_create_alias`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ClusterFirewallCreateAliasError {
22    Status400(models::PveError),
23    Status401(models::PveError),
24    Status403(models::PveError),
25    Status404(models::PveError),
26    Status500(models::PveError),
27    Status501(models::PveError),
28    Status503(models::PveError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`cluster_firewall_create_ip`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum ClusterFirewallCreateIpError {
36    Status400(models::PveError),
37    Status401(models::PveError),
38    Status403(models::PveError),
39    Status404(models::PveError),
40    Status500(models::PveError),
41    Status501(models::PveError),
42    Status503(models::PveError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`cluster_firewall_create_ipset`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ClusterFirewallCreateIpsetError {
50    Status400(models::PveError),
51    Status401(models::PveError),
52    Status403(models::PveError),
53    Status404(models::PveError),
54    Status500(models::PveError),
55    Status501(models::PveError),
56    Status503(models::PveError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`cluster_firewall_create_rule`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum ClusterFirewallCreateRuleError {
64    Status400(models::PveError),
65    Status401(models::PveError),
66    Status403(models::PveError),
67    Status404(models::PveError),
68    Status500(models::PveError),
69    Status501(models::PveError),
70    Status503(models::PveError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`cluster_firewall_create_rules`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum ClusterFirewallCreateRulesError {
78    Status400(models::PveError),
79    Status401(models::PveError),
80    Status403(models::PveError),
81    Status404(models::PveError),
82    Status500(models::PveError),
83    Status501(models::PveError),
84    Status503(models::PveError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`cluster_firewall_create_security_group`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum ClusterFirewallCreateSecurityGroupError {
92    Status400(models::PveError),
93    Status401(models::PveError),
94    Status403(models::PveError),
95    Status404(models::PveError),
96    Status500(models::PveError),
97    Status501(models::PveError),
98    Status503(models::PveError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`cluster_firewall_delete_ipset`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum ClusterFirewallDeleteIpsetError {
106    Status400(models::PveError),
107    Status401(models::PveError),
108    Status403(models::PveError),
109    Status404(models::PveError),
110    Status500(models::PveError),
111    Status501(models::PveError),
112    Status503(models::PveError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`cluster_firewall_delete_rule`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum ClusterFirewallDeleteRuleError {
120    Status400(models::PveError),
121    Status401(models::PveError),
122    Status403(models::PveError),
123    Status404(models::PveError),
124    Status500(models::PveError),
125    Status501(models::PveError),
126    Status503(models::PveError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`cluster_firewall_delete_rules`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum ClusterFirewallDeleteRulesError {
134    Status400(models::PveError),
135    Status401(models::PveError),
136    Status403(models::PveError),
137    Status404(models::PveError),
138    Status500(models::PveError),
139    Status501(models::PveError),
140    Status503(models::PveError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`cluster_firewall_delete_security_group`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum ClusterFirewallDeleteSecurityGroupError {
148    Status400(models::PveError),
149    Status401(models::PveError),
150    Status403(models::PveError),
151    Status404(models::PveError),
152    Status500(models::PveError),
153    Status501(models::PveError),
154    Status503(models::PveError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`cluster_firewall_get_aliases`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum ClusterFirewallGetAliasesError {
162    Status400(models::PveError),
163    Status401(models::PveError),
164    Status403(models::PveError),
165    Status404(models::PveError),
166    Status500(models::PveError),
167    Status501(models::PveError),
168    Status503(models::PveError),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`cluster_firewall_get_firewall`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum ClusterFirewallGetFirewallError {
176    Status400(models::PveError),
177    Status401(models::PveError),
178    Status403(models::PveError),
179    Status404(models::PveError),
180    Status500(models::PveError),
181    Status501(models::PveError),
182    Status503(models::PveError),
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`cluster_firewall_get_ipset`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum ClusterFirewallGetIpsetError {
190    Status400(models::PveError),
191    Status401(models::PveError),
192    Status403(models::PveError),
193    Status404(models::PveError),
194    Status500(models::PveError),
195    Status501(models::PveError),
196    Status503(models::PveError),
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`cluster_firewall_get_macros`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum ClusterFirewallGetMacrosError {
204    Status400(models::PveError),
205    Status401(models::PveError),
206    Status403(models::PveError),
207    Status404(models::PveError),
208    Status500(models::PveError),
209    Status501(models::PveError),
210    Status503(models::PveError),
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`cluster_firewall_get_options`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum ClusterFirewallGetOptionsError {
218    Status400(models::PveError),
219    Status401(models::PveError),
220    Status403(models::PveError),
221    Status404(models::PveError),
222    Status500(models::PveError),
223    Status501(models::PveError),
224    Status503(models::PveError),
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`cluster_firewall_get_rule`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum ClusterFirewallGetRuleError {
232    Status400(models::PveError),
233    Status401(models::PveError),
234    Status403(models::PveError),
235    Status404(models::PveError),
236    Status500(models::PveError),
237    Status501(models::PveError),
238    Status503(models::PveError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`cluster_firewall_get_rule_get_rules`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum ClusterFirewallGetRuleGetRulesError {
246    Status400(models::PveError),
247    Status401(models::PveError),
248    Status403(models::PveError),
249    Status404(models::PveError),
250    Status500(models::PveError),
251    Status501(models::PveError),
252    Status503(models::PveError),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`cluster_firewall_get_rules`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum ClusterFirewallGetRulesError {
260    Status400(models::PveError),
261    Status401(models::PveError),
262    Status403(models::PveError),
263    Status404(models::PveError),
264    Status500(models::PveError),
265    Status501(models::PveError),
266    Status503(models::PveError),
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`cluster_firewall_get_rules_get_rules`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum ClusterFirewallGetRulesGetRulesError {
274    Status400(models::PveError),
275    Status401(models::PveError),
276    Status403(models::PveError),
277    Status404(models::PveError),
278    Status500(models::PveError),
279    Status501(models::PveError),
280    Status503(models::PveError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`cluster_firewall_ipset_index`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum ClusterFirewallIpsetIndexError {
288    Status400(models::PveError),
289    Status401(models::PveError),
290    Status403(models::PveError),
291    Status404(models::PveError),
292    Status500(models::PveError),
293    Status501(models::PveError),
294    Status503(models::PveError),
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`cluster_firewall_list_security_groups`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum ClusterFirewallListSecurityGroupsError {
302    Status400(models::PveError),
303    Status401(models::PveError),
304    Status403(models::PveError),
305    Status404(models::PveError),
306    Status500(models::PveError),
307    Status501(models::PveError),
308    Status503(models::PveError),
309    UnknownValue(serde_json::Value),
310}
311
312/// struct for typed errors of method [`cluster_firewall_read_alias`]
313#[derive(Debug, Clone, Serialize, Deserialize)]
314#[serde(untagged)]
315pub enum ClusterFirewallReadAliasError {
316    Status400(models::PveError),
317    Status401(models::PveError),
318    Status403(models::PveError),
319    Status404(models::PveError),
320    Status500(models::PveError),
321    Status501(models::PveError),
322    Status503(models::PveError),
323    UnknownValue(serde_json::Value),
324}
325
326/// struct for typed errors of method [`cluster_firewall_read_ip`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum ClusterFirewallReadIpError {
330    Status400(models::PveError),
331    Status401(models::PveError),
332    Status403(models::PveError),
333    Status404(models::PveError),
334    Status500(models::PveError),
335    Status501(models::PveError),
336    Status503(models::PveError),
337    UnknownValue(serde_json::Value),
338}
339
340/// struct for typed errors of method [`cluster_firewall_refs`]
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum ClusterFirewallRefsError {
344    Status400(models::PveError),
345    Status401(models::PveError),
346    Status403(models::PveError),
347    Status404(models::PveError),
348    Status500(models::PveError),
349    Status501(models::PveError),
350    Status503(models::PveError),
351    UnknownValue(serde_json::Value),
352}
353
354/// struct for typed errors of method [`cluster_firewall_remove_alias`]
355#[derive(Debug, Clone, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum ClusterFirewallRemoveAliasError {
358    Status400(models::PveError),
359    Status401(models::PveError),
360    Status403(models::PveError),
361    Status404(models::PveError),
362    Status500(models::PveError),
363    Status501(models::PveError),
364    Status503(models::PveError),
365    UnknownValue(serde_json::Value),
366}
367
368/// struct for typed errors of method [`cluster_firewall_remove_ip`]
369#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum ClusterFirewallRemoveIpError {
372    Status400(models::PveError),
373    Status401(models::PveError),
374    Status403(models::PveError),
375    Status404(models::PveError),
376    Status500(models::PveError),
377    Status501(models::PveError),
378    Status503(models::PveError),
379    UnknownValue(serde_json::Value),
380}
381
382/// struct for typed errors of method [`cluster_firewall_set_options`]
383#[derive(Debug, Clone, Serialize, Deserialize)]
384#[serde(untagged)]
385pub enum ClusterFirewallSetOptionsError {
386    Status400(models::PveError),
387    Status401(models::PveError),
388    Status403(models::PveError),
389    Status404(models::PveError),
390    Status500(models::PveError),
391    Status501(models::PveError),
392    Status503(models::PveError),
393    UnknownValue(serde_json::Value),
394}
395
396/// struct for typed errors of method [`cluster_firewall_update_alias`]
397#[derive(Debug, Clone, Serialize, Deserialize)]
398#[serde(untagged)]
399pub enum ClusterFirewallUpdateAliasError {
400    Status400(models::PveError),
401    Status401(models::PveError),
402    Status403(models::PveError),
403    Status404(models::PveError),
404    Status500(models::PveError),
405    Status501(models::PveError),
406    Status503(models::PveError),
407    UnknownValue(serde_json::Value),
408}
409
410/// struct for typed errors of method [`cluster_firewall_update_ip`]
411#[derive(Debug, Clone, Serialize, Deserialize)]
412#[serde(untagged)]
413pub enum ClusterFirewallUpdateIpError {
414    Status400(models::PveError),
415    Status401(models::PveError),
416    Status403(models::PveError),
417    Status404(models::PveError),
418    Status500(models::PveError),
419    Status501(models::PveError),
420    Status503(models::PveError),
421    UnknownValue(serde_json::Value),
422}
423
424/// struct for typed errors of method [`cluster_firewall_update_rule`]
425#[derive(Debug, Clone, Serialize, Deserialize)]
426#[serde(untagged)]
427pub enum ClusterFirewallUpdateRuleError {
428    Status400(models::PveError),
429    Status401(models::PveError),
430    Status403(models::PveError),
431    Status404(models::PveError),
432    Status500(models::PveError),
433    Status501(models::PveError),
434    Status503(models::PveError),
435    UnknownValue(serde_json::Value),
436}
437
438/// struct for typed errors of method [`cluster_firewall_update_rules`]
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(untagged)]
441pub enum ClusterFirewallUpdateRulesError {
442    Status400(models::PveError),
443    Status401(models::PveError),
444    Status403(models::PveError),
445    Status404(models::PveError),
446    Status500(models::PveError),
447    Status501(models::PveError),
448    Status503(models::PveError),
449    UnknownValue(serde_json::Value),
450}
451
452
453/// Create IP or Network Alias.
454pub async fn cluster_firewall_create_alias(configuration: &configuration::Configuration, cluster_firewall_create_alias_request: models::ClusterFirewallCreateAliasRequest) -> Result<models::ClusterFirewallCreateAliasResponse, Error<ClusterFirewallCreateAliasError>> {
455    // add a prefix to parameters to efficiently prevent name collisions
456    let p_body_cluster_firewall_create_alias_request = cluster_firewall_create_alias_request;
457
458    let uri_str = format!("{}/cluster/firewall/aliases", configuration.base_path);
459    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
460
461    if let Some(ref user_agent) = configuration.user_agent {
462        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
463    }
464    if let Some(ref apikey) = configuration.api_key {
465        let key = apikey.key.clone();
466        let value = match apikey.prefix {
467            Some(ref prefix) => format!("{} {}", prefix, key),
468            None => key,
469        };
470        req_builder = req_builder.header("Authorization", value);
471    };
472    if let Some(ref apikey) = configuration.api_key {
473        let key = apikey.key.clone();
474        let value = match apikey.prefix {
475            Some(ref prefix) => format!("{} {}", prefix, key),
476            None => key,
477        };
478        req_builder = req_builder.header("CSRFPreventionToken", value);
479    };
480    req_builder = req_builder.json(&p_body_cluster_firewall_create_alias_request);
481
482    let req = req_builder.build()?;
483    let resp = configuration.client.execute(req).await?;
484
485    let status = resp.status();
486    let content_type = resp
487        .headers()
488        .get("content-type")
489        .and_then(|v| v.to_str().ok())
490        .unwrap_or("application/octet-stream");
491    let content_type = super::ContentType::from(content_type);
492
493    if !status.is_client_error() && !status.is_server_error() {
494        let content = resp.text().await?;
495        match content_type {
496            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
497            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateAliasResponse`"))),
498            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateAliasResponse`")))),
499        }
500    } else {
501        let content = resp.text().await?;
502        let entity: Option<ClusterFirewallCreateAliasError> = serde_json::from_str(&content).ok();
503        Err(Error::ResponseError(ResponseContent { status, content, entity }))
504    }
505}
506
507/// Add IP or Network to IPSet.
508pub async fn cluster_firewall_create_ip(configuration: &configuration::Configuration, name: &str, cluster_firewall_create_ip_request: models::ClusterFirewallCreateIpRequest) -> Result<models::ClusterFirewallCreateIpResponse, Error<ClusterFirewallCreateIpError>> {
509    // add a prefix to parameters to efficiently prevent name collisions
510    let p_path_name = name;
511    let p_body_cluster_firewall_create_ip_request = cluster_firewall_create_ip_request;
512
513    let uri_str = format!("{}/cluster/firewall/ipset/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
514    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
515
516    if let Some(ref user_agent) = configuration.user_agent {
517        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
518    }
519    if let Some(ref apikey) = configuration.api_key {
520        let key = apikey.key.clone();
521        let value = match apikey.prefix {
522            Some(ref prefix) => format!("{} {}", prefix, key),
523            None => key,
524        };
525        req_builder = req_builder.header("Authorization", value);
526    };
527    if let Some(ref apikey) = configuration.api_key {
528        let key = apikey.key.clone();
529        let value = match apikey.prefix {
530            Some(ref prefix) => format!("{} {}", prefix, key),
531            None => key,
532        };
533        req_builder = req_builder.header("CSRFPreventionToken", value);
534    };
535    req_builder = req_builder.json(&p_body_cluster_firewall_create_ip_request);
536
537    let req = req_builder.build()?;
538    let resp = configuration.client.execute(req).await?;
539
540    let status = resp.status();
541    let content_type = resp
542        .headers()
543        .get("content-type")
544        .and_then(|v| v.to_str().ok())
545        .unwrap_or("application/octet-stream");
546    let content_type = super::ContentType::from(content_type);
547
548    if !status.is_client_error() && !status.is_server_error() {
549        let content = resp.text().await?;
550        match content_type {
551            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
552            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateIpResponse`"))),
553            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateIpResponse`")))),
554        }
555    } else {
556        let content = resp.text().await?;
557        let entity: Option<ClusterFirewallCreateIpError> = serde_json::from_str(&content).ok();
558        Err(Error::ResponseError(ResponseContent { status, content, entity }))
559    }
560}
561
562/// Create new IPSet
563pub async fn cluster_firewall_create_ipset(configuration: &configuration::Configuration, cluster_firewall_create_ipset_request: models::ClusterFirewallCreateIpsetRequest) -> Result<models::ClusterFirewallCreateIpsetResponse, Error<ClusterFirewallCreateIpsetError>> {
564    // add a prefix to parameters to efficiently prevent name collisions
565    let p_body_cluster_firewall_create_ipset_request = cluster_firewall_create_ipset_request;
566
567    let uri_str = format!("{}/cluster/firewall/ipset", configuration.base_path);
568    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
569
570    if let Some(ref user_agent) = configuration.user_agent {
571        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
572    }
573    if let Some(ref apikey) = configuration.api_key {
574        let key = apikey.key.clone();
575        let value = match apikey.prefix {
576            Some(ref prefix) => format!("{} {}", prefix, key),
577            None => key,
578        };
579        req_builder = req_builder.header("Authorization", value);
580    };
581    if let Some(ref apikey) = configuration.api_key {
582        let key = apikey.key.clone();
583        let value = match apikey.prefix {
584            Some(ref prefix) => format!("{} {}", prefix, key),
585            None => key,
586        };
587        req_builder = req_builder.header("CSRFPreventionToken", value);
588    };
589    req_builder = req_builder.json(&p_body_cluster_firewall_create_ipset_request);
590
591    let req = req_builder.build()?;
592    let resp = configuration.client.execute(req).await?;
593
594    let status = resp.status();
595    let content_type = resp
596        .headers()
597        .get("content-type")
598        .and_then(|v| v.to_str().ok())
599        .unwrap_or("application/octet-stream");
600    let content_type = super::ContentType::from(content_type);
601
602    if !status.is_client_error() && !status.is_server_error() {
603        let content = resp.text().await?;
604        match content_type {
605            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
606            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateIpsetResponse`"))),
607            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateIpsetResponse`")))),
608        }
609    } else {
610        let content = resp.text().await?;
611        let entity: Option<ClusterFirewallCreateIpsetError> = serde_json::from_str(&content).ok();
612        Err(Error::ResponseError(ResponseContent { status, content, entity }))
613    }
614}
615
616/// Create new rule.
617pub async fn cluster_firewall_create_rule(configuration: &configuration::Configuration, group: &str, cluster_firewall_create_rule_request: models::ClusterFirewallCreateRuleRequest) -> Result<models::ClusterFirewallCreateRuleResponse, Error<ClusterFirewallCreateRuleError>> {
618    // add a prefix to parameters to efficiently prevent name collisions
619    let p_path_group = group;
620    let p_body_cluster_firewall_create_rule_request = cluster_firewall_create_rule_request;
621
622    let uri_str = format!("{}/cluster/firewall/groups/{group}", configuration.base_path, group=crate::apis::urlencode(p_path_group));
623    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
624
625    if let Some(ref user_agent) = configuration.user_agent {
626        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
627    }
628    if let Some(ref apikey) = configuration.api_key {
629        let key = apikey.key.clone();
630        let value = match apikey.prefix {
631            Some(ref prefix) => format!("{} {}", prefix, key),
632            None => key,
633        };
634        req_builder = req_builder.header("Authorization", value);
635    };
636    if let Some(ref apikey) = configuration.api_key {
637        let key = apikey.key.clone();
638        let value = match apikey.prefix {
639            Some(ref prefix) => format!("{} {}", prefix, key),
640            None => key,
641        };
642        req_builder = req_builder.header("CSRFPreventionToken", value);
643    };
644    req_builder = req_builder.json(&p_body_cluster_firewall_create_rule_request);
645
646    let req = req_builder.build()?;
647    let resp = configuration.client.execute(req).await?;
648
649    let status = resp.status();
650    let content_type = resp
651        .headers()
652        .get("content-type")
653        .and_then(|v| v.to_str().ok())
654        .unwrap_or("application/octet-stream");
655    let content_type = super::ContentType::from(content_type);
656
657    if !status.is_client_error() && !status.is_server_error() {
658        let content = resp.text().await?;
659        match content_type {
660            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
661            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateRuleResponse`"))),
662            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateRuleResponse`")))),
663        }
664    } else {
665        let content = resp.text().await?;
666        let entity: Option<ClusterFirewallCreateRuleError> = serde_json::from_str(&content).ok();
667        Err(Error::ResponseError(ResponseContent { status, content, entity }))
668    }
669}
670
671/// Create new rule.
672pub async fn cluster_firewall_create_rules(configuration: &configuration::Configuration, cluster_firewall_create_rule_request: models::ClusterFirewallCreateRuleRequest) -> Result<models::ClusterFirewallCreateRulesResponse, Error<ClusterFirewallCreateRulesError>> {
673    // add a prefix to parameters to efficiently prevent name collisions
674    let p_body_cluster_firewall_create_rule_request = cluster_firewall_create_rule_request;
675
676    let uri_str = format!("{}/cluster/firewall/rules", configuration.base_path);
677    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
678
679    if let Some(ref user_agent) = configuration.user_agent {
680        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
681    }
682    if let Some(ref apikey) = configuration.api_key {
683        let key = apikey.key.clone();
684        let value = match apikey.prefix {
685            Some(ref prefix) => format!("{} {}", prefix, key),
686            None => key,
687        };
688        req_builder = req_builder.header("Authorization", value);
689    };
690    if let Some(ref apikey) = configuration.api_key {
691        let key = apikey.key.clone();
692        let value = match apikey.prefix {
693            Some(ref prefix) => format!("{} {}", prefix, key),
694            None => key,
695        };
696        req_builder = req_builder.header("CSRFPreventionToken", value);
697    };
698    req_builder = req_builder.json(&p_body_cluster_firewall_create_rule_request);
699
700    let req = req_builder.build()?;
701    let resp = configuration.client.execute(req).await?;
702
703    let status = resp.status();
704    let content_type = resp
705        .headers()
706        .get("content-type")
707        .and_then(|v| v.to_str().ok())
708        .unwrap_or("application/octet-stream");
709    let content_type = super::ContentType::from(content_type);
710
711    if !status.is_client_error() && !status.is_server_error() {
712        let content = resp.text().await?;
713        match content_type {
714            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
715            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateRulesResponse`"))),
716            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateRulesResponse`")))),
717        }
718    } else {
719        let content = resp.text().await?;
720        let entity: Option<ClusterFirewallCreateRulesError> = serde_json::from_str(&content).ok();
721        Err(Error::ResponseError(ResponseContent { status, content, entity }))
722    }
723}
724
725/// Create new security group.
726pub async fn cluster_firewall_create_security_group(configuration: &configuration::Configuration, cluster_firewall_create_security_group_request: models::ClusterFirewallCreateSecurityGroupRequest) -> Result<models::ClusterFirewallCreateSecurityGroupResponse, Error<ClusterFirewallCreateSecurityGroupError>> {
727    // add a prefix to parameters to efficiently prevent name collisions
728    let p_body_cluster_firewall_create_security_group_request = cluster_firewall_create_security_group_request;
729
730    let uri_str = format!("{}/cluster/firewall/groups", configuration.base_path);
731    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
732
733    if let Some(ref user_agent) = configuration.user_agent {
734        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
735    }
736    if let Some(ref apikey) = configuration.api_key {
737        let key = apikey.key.clone();
738        let value = match apikey.prefix {
739            Some(ref prefix) => format!("{} {}", prefix, key),
740            None => key,
741        };
742        req_builder = req_builder.header("Authorization", value);
743    };
744    if let Some(ref apikey) = configuration.api_key {
745        let key = apikey.key.clone();
746        let value = match apikey.prefix {
747            Some(ref prefix) => format!("{} {}", prefix, key),
748            None => key,
749        };
750        req_builder = req_builder.header("CSRFPreventionToken", value);
751    };
752    req_builder = req_builder.json(&p_body_cluster_firewall_create_security_group_request);
753
754    let req = req_builder.build()?;
755    let resp = configuration.client.execute(req).await?;
756
757    let status = resp.status();
758    let content_type = resp
759        .headers()
760        .get("content-type")
761        .and_then(|v| v.to_str().ok())
762        .unwrap_or("application/octet-stream");
763    let content_type = super::ContentType::from(content_type);
764
765    if !status.is_client_error() && !status.is_server_error() {
766        let content = resp.text().await?;
767        match content_type {
768            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
769            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallCreateSecurityGroupResponse`"))),
770            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallCreateSecurityGroupResponse`")))),
771        }
772    } else {
773        let content = resp.text().await?;
774        let entity: Option<ClusterFirewallCreateSecurityGroupError> = serde_json::from_str(&content).ok();
775        Err(Error::ResponseError(ResponseContent { status, content, entity }))
776    }
777}
778
779/// Delete IPSet
780pub async fn cluster_firewall_delete_ipset(configuration: &configuration::Configuration, name: &str, force: Option<&str>) -> Result<models::ClusterFirewallDeleteIpsetResponse, Error<ClusterFirewallDeleteIpsetError>> {
781    // add a prefix to parameters to efficiently prevent name collisions
782    let p_path_name = name;
783    let p_query_force = force;
784
785    let uri_str = format!("{}/cluster/firewall/ipset/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
786    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
787
788    if let Some(ref param_value) = p_query_force {
789        req_builder = req_builder.query(&[("force", &param_value.to_string())]);
790    }
791    if let Some(ref user_agent) = configuration.user_agent {
792        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
793    }
794    if let Some(ref apikey) = configuration.api_key {
795        let key = apikey.key.clone();
796        let value = match apikey.prefix {
797            Some(ref prefix) => format!("{} {}", prefix, key),
798            None => key,
799        };
800        req_builder = req_builder.header("Authorization", value);
801    };
802    if let Some(ref apikey) = configuration.api_key {
803        let key = apikey.key.clone();
804        let value = match apikey.prefix {
805            Some(ref prefix) => format!("{} {}", prefix, key),
806            None => key,
807        };
808        req_builder = req_builder.header("CSRFPreventionToken", value);
809    };
810
811    let req = req_builder.build()?;
812    let resp = configuration.client.execute(req).await?;
813
814    let status = resp.status();
815    let content_type = resp
816        .headers()
817        .get("content-type")
818        .and_then(|v| v.to_str().ok())
819        .unwrap_or("application/octet-stream");
820    let content_type = super::ContentType::from(content_type);
821
822    if !status.is_client_error() && !status.is_server_error() {
823        let content = resp.text().await?;
824        match content_type {
825            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
826            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallDeleteIpsetResponse`"))),
827            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallDeleteIpsetResponse`")))),
828        }
829    } else {
830        let content = resp.text().await?;
831        let entity: Option<ClusterFirewallDeleteIpsetError> = serde_json::from_str(&content).ok();
832        Err(Error::ResponseError(ResponseContent { status, content, entity }))
833    }
834}
835
836/// Delete rule.
837pub async fn cluster_firewall_delete_rule(configuration: &configuration::Configuration, group: &str, pos: i64, digest: Option<&str>) -> Result<models::ClusterFirewallDeleteRuleResponse, Error<ClusterFirewallDeleteRuleError>> {
838    // add a prefix to parameters to efficiently prevent name collisions
839    let p_path_group = group;
840    let p_path_pos = pos;
841    let p_query_digest = digest;
842
843    let uri_str = format!("{}/cluster/firewall/groups/{group}/{pos}", configuration.base_path, group=crate::apis::urlencode(p_path_group), pos=p_path_pos);
844    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
845
846    if let Some(ref param_value) = p_query_digest {
847        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
848    }
849    if let Some(ref user_agent) = configuration.user_agent {
850        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
851    }
852    if let Some(ref apikey) = configuration.api_key {
853        let key = apikey.key.clone();
854        let value = match apikey.prefix {
855            Some(ref prefix) => format!("{} {}", prefix, key),
856            None => key,
857        };
858        req_builder = req_builder.header("Authorization", value);
859    };
860    if let Some(ref apikey) = configuration.api_key {
861        let key = apikey.key.clone();
862        let value = match apikey.prefix {
863            Some(ref prefix) => format!("{} {}", prefix, key),
864            None => key,
865        };
866        req_builder = req_builder.header("CSRFPreventionToken", value);
867    };
868
869    let req = req_builder.build()?;
870    let resp = configuration.client.execute(req).await?;
871
872    let status = resp.status();
873    let content_type = resp
874        .headers()
875        .get("content-type")
876        .and_then(|v| v.to_str().ok())
877        .unwrap_or("application/octet-stream");
878    let content_type = super::ContentType::from(content_type);
879
880    if !status.is_client_error() && !status.is_server_error() {
881        let content = resp.text().await?;
882        match content_type {
883            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
884            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallDeleteRuleResponse`"))),
885            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallDeleteRuleResponse`")))),
886        }
887    } else {
888        let content = resp.text().await?;
889        let entity: Option<ClusterFirewallDeleteRuleError> = serde_json::from_str(&content).ok();
890        Err(Error::ResponseError(ResponseContent { status, content, entity }))
891    }
892}
893
894/// Delete rule.
895pub async fn cluster_firewall_delete_rules(configuration: &configuration::Configuration, pos: i64, digest: Option<&str>) -> Result<models::ClusterFirewallDeleteRulesResponse, Error<ClusterFirewallDeleteRulesError>> {
896    // add a prefix to parameters to efficiently prevent name collisions
897    let p_path_pos = pos;
898    let p_query_digest = digest;
899
900    let uri_str = format!("{}/cluster/firewall/rules/{pos}", configuration.base_path, pos=p_path_pos);
901    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
902
903    if let Some(ref param_value) = p_query_digest {
904        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
905    }
906    if let Some(ref user_agent) = configuration.user_agent {
907        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
908    }
909    if let Some(ref apikey) = configuration.api_key {
910        let key = apikey.key.clone();
911        let value = match apikey.prefix {
912            Some(ref prefix) => format!("{} {}", prefix, key),
913            None => key,
914        };
915        req_builder = req_builder.header("Authorization", value);
916    };
917    if let Some(ref apikey) = configuration.api_key {
918        let key = apikey.key.clone();
919        let value = match apikey.prefix {
920            Some(ref prefix) => format!("{} {}", prefix, key),
921            None => key,
922        };
923        req_builder = req_builder.header("CSRFPreventionToken", value);
924    };
925
926    let req = req_builder.build()?;
927    let resp = configuration.client.execute(req).await?;
928
929    let status = resp.status();
930    let content_type = resp
931        .headers()
932        .get("content-type")
933        .and_then(|v| v.to_str().ok())
934        .unwrap_or("application/octet-stream");
935    let content_type = super::ContentType::from(content_type);
936
937    if !status.is_client_error() && !status.is_server_error() {
938        let content = resp.text().await?;
939        match content_type {
940            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
941            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallDeleteRulesResponse`"))),
942            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallDeleteRulesResponse`")))),
943        }
944    } else {
945        let content = resp.text().await?;
946        let entity: Option<ClusterFirewallDeleteRulesError> = serde_json::from_str(&content).ok();
947        Err(Error::ResponseError(ResponseContent { status, content, entity }))
948    }
949}
950
951/// Delete security group.
952pub async fn cluster_firewall_delete_security_group(configuration: &configuration::Configuration, group: &str) -> Result<models::ClusterFirewallDeleteSecurityGroupResponse, Error<ClusterFirewallDeleteSecurityGroupError>> {
953    // add a prefix to parameters to efficiently prevent name collisions
954    let p_path_group = group;
955
956    let uri_str = format!("{}/cluster/firewall/groups/{group}", configuration.base_path, group=crate::apis::urlencode(p_path_group));
957    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
958
959    if let Some(ref user_agent) = configuration.user_agent {
960        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
961    }
962    if let Some(ref apikey) = configuration.api_key {
963        let key = apikey.key.clone();
964        let value = match apikey.prefix {
965            Some(ref prefix) => format!("{} {}", prefix, key),
966            None => key,
967        };
968        req_builder = req_builder.header("Authorization", value);
969    };
970    if let Some(ref apikey) = configuration.api_key {
971        let key = apikey.key.clone();
972        let value = match apikey.prefix {
973            Some(ref prefix) => format!("{} {}", prefix, key),
974            None => key,
975        };
976        req_builder = req_builder.header("CSRFPreventionToken", value);
977    };
978
979    let req = req_builder.build()?;
980    let resp = configuration.client.execute(req).await?;
981
982    let status = resp.status();
983    let content_type = resp
984        .headers()
985        .get("content-type")
986        .and_then(|v| v.to_str().ok())
987        .unwrap_or("application/octet-stream");
988    let content_type = super::ContentType::from(content_type);
989
990    if !status.is_client_error() && !status.is_server_error() {
991        let content = resp.text().await?;
992        match content_type {
993            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
994            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallDeleteSecurityGroupResponse`"))),
995            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallDeleteSecurityGroupResponse`")))),
996        }
997    } else {
998        let content = resp.text().await?;
999        let entity: Option<ClusterFirewallDeleteSecurityGroupError> = serde_json::from_str(&content).ok();
1000        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1001    }
1002}
1003
1004/// List aliases
1005pub async fn cluster_firewall_get_aliases(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallGetAliasesResponse, Error<ClusterFirewallGetAliasesError>> {
1006
1007    let uri_str = format!("{}/cluster/firewall/aliases", configuration.base_path);
1008    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1009
1010    if let Some(ref user_agent) = configuration.user_agent {
1011        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1012    }
1013    if let Some(ref apikey) = configuration.api_key {
1014        let key = apikey.key.clone();
1015        let value = match apikey.prefix {
1016            Some(ref prefix) => format!("{} {}", prefix, key),
1017            None => key,
1018        };
1019        req_builder = req_builder.header("Authorization", value);
1020    };
1021    if let Some(ref apikey) = configuration.api_key {
1022        let key = apikey.key.clone();
1023        let value = match apikey.prefix {
1024            Some(ref prefix) => format!("{} {}", prefix, key),
1025            None => key,
1026        };
1027        req_builder = req_builder.header("CSRFPreventionToken", value);
1028    };
1029
1030    let req = req_builder.build()?;
1031    let resp = configuration.client.execute(req).await?;
1032
1033    let status = resp.status();
1034    let content_type = resp
1035        .headers()
1036        .get("content-type")
1037        .and_then(|v| v.to_str().ok())
1038        .unwrap_or("application/octet-stream");
1039    let content_type = super::ContentType::from(content_type);
1040
1041    if !status.is_client_error() && !status.is_server_error() {
1042        let content = resp.text().await?;
1043        match content_type {
1044            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1045            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetAliasesResponse`"))),
1046            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetAliasesResponse`")))),
1047        }
1048    } else {
1049        let content = resp.text().await?;
1050        let entity: Option<ClusterFirewallGetAliasesError> = serde_json::from_str(&content).ok();
1051        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1052    }
1053}
1054
1055/// Directory index.
1056pub async fn cluster_firewall_get_firewall(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallGetFirewallResponse, Error<ClusterFirewallGetFirewallError>> {
1057
1058    let uri_str = format!("{}/cluster/firewall", configuration.base_path);
1059    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1060
1061    if let Some(ref user_agent) = configuration.user_agent {
1062        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1063    }
1064    if let Some(ref apikey) = configuration.api_key {
1065        let key = apikey.key.clone();
1066        let value = match apikey.prefix {
1067            Some(ref prefix) => format!("{} {}", prefix, key),
1068            None => key,
1069        };
1070        req_builder = req_builder.header("Authorization", value);
1071    };
1072    if let Some(ref apikey) = configuration.api_key {
1073        let key = apikey.key.clone();
1074        let value = match apikey.prefix {
1075            Some(ref prefix) => format!("{} {}", prefix, key),
1076            None => key,
1077        };
1078        req_builder = req_builder.header("CSRFPreventionToken", value);
1079    };
1080
1081    let req = req_builder.build()?;
1082    let resp = configuration.client.execute(req).await?;
1083
1084    let status = resp.status();
1085    let content_type = resp
1086        .headers()
1087        .get("content-type")
1088        .and_then(|v| v.to_str().ok())
1089        .unwrap_or("application/octet-stream");
1090    let content_type = super::ContentType::from(content_type);
1091
1092    if !status.is_client_error() && !status.is_server_error() {
1093        let content = resp.text().await?;
1094        match content_type {
1095            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1096            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetFirewallResponse`"))),
1097            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetFirewallResponse`")))),
1098        }
1099    } else {
1100        let content = resp.text().await?;
1101        let entity: Option<ClusterFirewallGetFirewallError> = serde_json::from_str(&content).ok();
1102        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1103    }
1104}
1105
1106/// List IPSet content
1107pub async fn cluster_firewall_get_ipset(configuration: &configuration::Configuration, name: &str) -> Result<models::ClusterFirewallGetIpsetResponse, Error<ClusterFirewallGetIpsetError>> {
1108    // add a prefix to parameters to efficiently prevent name collisions
1109    let p_path_name = name;
1110
1111    let uri_str = format!("{}/cluster/firewall/ipset/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
1112    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1113
1114    if let Some(ref user_agent) = configuration.user_agent {
1115        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1116    }
1117    if let Some(ref apikey) = configuration.api_key {
1118        let key = apikey.key.clone();
1119        let value = match apikey.prefix {
1120            Some(ref prefix) => format!("{} {}", prefix, key),
1121            None => key,
1122        };
1123        req_builder = req_builder.header("Authorization", value);
1124    };
1125    if let Some(ref apikey) = configuration.api_key {
1126        let key = apikey.key.clone();
1127        let value = match apikey.prefix {
1128            Some(ref prefix) => format!("{} {}", prefix, key),
1129            None => key,
1130        };
1131        req_builder = req_builder.header("CSRFPreventionToken", value);
1132    };
1133
1134    let req = req_builder.build()?;
1135    let resp = configuration.client.execute(req).await?;
1136
1137    let status = resp.status();
1138    let content_type = resp
1139        .headers()
1140        .get("content-type")
1141        .and_then(|v| v.to_str().ok())
1142        .unwrap_or("application/octet-stream");
1143    let content_type = super::ContentType::from(content_type);
1144
1145    if !status.is_client_error() && !status.is_server_error() {
1146        let content = resp.text().await?;
1147        match content_type {
1148            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1149            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetIpsetResponse`"))),
1150            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetIpsetResponse`")))),
1151        }
1152    } else {
1153        let content = resp.text().await?;
1154        let entity: Option<ClusterFirewallGetIpsetError> = serde_json::from_str(&content).ok();
1155        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1156    }
1157}
1158
1159/// List available macros
1160pub async fn cluster_firewall_get_macros(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallGetMacrosResponse, Error<ClusterFirewallGetMacrosError>> {
1161
1162    let uri_str = format!("{}/cluster/firewall/macros", configuration.base_path);
1163    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1164
1165    if let Some(ref user_agent) = configuration.user_agent {
1166        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1167    }
1168    if let Some(ref apikey) = configuration.api_key {
1169        let key = apikey.key.clone();
1170        let value = match apikey.prefix {
1171            Some(ref prefix) => format!("{} {}", prefix, key),
1172            None => key,
1173        };
1174        req_builder = req_builder.header("Authorization", value);
1175    };
1176    if let Some(ref apikey) = configuration.api_key {
1177        let key = apikey.key.clone();
1178        let value = match apikey.prefix {
1179            Some(ref prefix) => format!("{} {}", prefix, key),
1180            None => key,
1181        };
1182        req_builder = req_builder.header("CSRFPreventionToken", value);
1183    };
1184
1185    let req = req_builder.build()?;
1186    let resp = configuration.client.execute(req).await?;
1187
1188    let status = resp.status();
1189    let content_type = resp
1190        .headers()
1191        .get("content-type")
1192        .and_then(|v| v.to_str().ok())
1193        .unwrap_or("application/octet-stream");
1194    let content_type = super::ContentType::from(content_type);
1195
1196    if !status.is_client_error() && !status.is_server_error() {
1197        let content = resp.text().await?;
1198        match content_type {
1199            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1200            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetMacrosResponse`"))),
1201            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetMacrosResponse`")))),
1202        }
1203    } else {
1204        let content = resp.text().await?;
1205        let entity: Option<ClusterFirewallGetMacrosError> = serde_json::from_str(&content).ok();
1206        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1207    }
1208}
1209
1210/// Get Firewall options.
1211pub async fn cluster_firewall_get_options(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallGetOptionsResponse, Error<ClusterFirewallGetOptionsError>> {
1212
1213    let uri_str = format!("{}/cluster/firewall/options", configuration.base_path);
1214    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1215
1216    if let Some(ref user_agent) = configuration.user_agent {
1217        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1218    }
1219    if let Some(ref apikey) = configuration.api_key {
1220        let key = apikey.key.clone();
1221        let value = match apikey.prefix {
1222            Some(ref prefix) => format!("{} {}", prefix, key),
1223            None => key,
1224        };
1225        req_builder = req_builder.header("Authorization", value);
1226    };
1227    if let Some(ref apikey) = configuration.api_key {
1228        let key = apikey.key.clone();
1229        let value = match apikey.prefix {
1230            Some(ref prefix) => format!("{} {}", prefix, key),
1231            None => key,
1232        };
1233        req_builder = req_builder.header("CSRFPreventionToken", value);
1234    };
1235
1236    let req = req_builder.build()?;
1237    let resp = configuration.client.execute(req).await?;
1238
1239    let status = resp.status();
1240    let content_type = resp
1241        .headers()
1242        .get("content-type")
1243        .and_then(|v| v.to_str().ok())
1244        .unwrap_or("application/octet-stream");
1245    let content_type = super::ContentType::from(content_type);
1246
1247    if !status.is_client_error() && !status.is_server_error() {
1248        let content = resp.text().await?;
1249        match content_type {
1250            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1251            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetOptionsResponse`"))),
1252            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetOptionsResponse`")))),
1253        }
1254    } else {
1255        let content = resp.text().await?;
1256        let entity: Option<ClusterFirewallGetOptionsError> = serde_json::from_str(&content).ok();
1257        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1258    }
1259}
1260
1261/// Get single rule data.
1262pub async fn cluster_firewall_get_rule(configuration: &configuration::Configuration, group: &str, pos: i64) -> Result<models::ClusterFirewallGetRuleResponse, Error<ClusterFirewallGetRuleError>> {
1263    // add a prefix to parameters to efficiently prevent name collisions
1264    let p_path_group = group;
1265    let p_path_pos = pos;
1266
1267    let uri_str = format!("{}/cluster/firewall/groups/{group}/{pos}", configuration.base_path, group=crate::apis::urlencode(p_path_group), pos=p_path_pos);
1268    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1269
1270    if let Some(ref user_agent) = configuration.user_agent {
1271        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1272    }
1273    if let Some(ref apikey) = configuration.api_key {
1274        let key = apikey.key.clone();
1275        let value = match apikey.prefix {
1276            Some(ref prefix) => format!("{} {}", prefix, key),
1277            None => key,
1278        };
1279        req_builder = req_builder.header("Authorization", value);
1280    };
1281    if let Some(ref apikey) = configuration.api_key {
1282        let key = apikey.key.clone();
1283        let value = match apikey.prefix {
1284            Some(ref prefix) => format!("{} {}", prefix, key),
1285            None => key,
1286        };
1287        req_builder = req_builder.header("CSRFPreventionToken", value);
1288    };
1289
1290    let req = req_builder.build()?;
1291    let resp = configuration.client.execute(req).await?;
1292
1293    let status = resp.status();
1294    let content_type = resp
1295        .headers()
1296        .get("content-type")
1297        .and_then(|v| v.to_str().ok())
1298        .unwrap_or("application/octet-stream");
1299    let content_type = super::ContentType::from(content_type);
1300
1301    if !status.is_client_error() && !status.is_server_error() {
1302        let content = resp.text().await?;
1303        match content_type {
1304            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1305            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetRuleResponse`"))),
1306            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetRuleResponse`")))),
1307        }
1308    } else {
1309        let content = resp.text().await?;
1310        let entity: Option<ClusterFirewallGetRuleError> = serde_json::from_str(&content).ok();
1311        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1312    }
1313}
1314
1315/// Get single rule data.
1316pub async fn cluster_firewall_get_rule_get_rules(configuration: &configuration::Configuration, pos: i64) -> Result<models::ClusterFirewallGetRuleGetRulesResponse, Error<ClusterFirewallGetRuleGetRulesError>> {
1317    // add a prefix to parameters to efficiently prevent name collisions
1318    let p_path_pos = pos;
1319
1320    let uri_str = format!("{}/cluster/firewall/rules/{pos}", configuration.base_path, pos=p_path_pos);
1321    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1322
1323    if let Some(ref user_agent) = configuration.user_agent {
1324        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1325    }
1326    if let Some(ref apikey) = configuration.api_key {
1327        let key = apikey.key.clone();
1328        let value = match apikey.prefix {
1329            Some(ref prefix) => format!("{} {}", prefix, key),
1330            None => key,
1331        };
1332        req_builder = req_builder.header("Authorization", value);
1333    };
1334    if let Some(ref apikey) = configuration.api_key {
1335        let key = apikey.key.clone();
1336        let value = match apikey.prefix {
1337            Some(ref prefix) => format!("{} {}", prefix, key),
1338            None => key,
1339        };
1340        req_builder = req_builder.header("CSRFPreventionToken", value);
1341    };
1342
1343    let req = req_builder.build()?;
1344    let resp = configuration.client.execute(req).await?;
1345
1346    let status = resp.status();
1347    let content_type = resp
1348        .headers()
1349        .get("content-type")
1350        .and_then(|v| v.to_str().ok())
1351        .unwrap_or("application/octet-stream");
1352    let content_type = super::ContentType::from(content_type);
1353
1354    if !status.is_client_error() && !status.is_server_error() {
1355        let content = resp.text().await?;
1356        match content_type {
1357            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1358            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetRuleGetRulesResponse`"))),
1359            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetRuleGetRulesResponse`")))),
1360        }
1361    } else {
1362        let content = resp.text().await?;
1363        let entity: Option<ClusterFirewallGetRuleGetRulesError> = serde_json::from_str(&content).ok();
1364        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1365    }
1366}
1367
1368/// List rules.
1369pub async fn cluster_firewall_get_rules(configuration: &configuration::Configuration, group: &str) -> Result<models::ClusterFirewallGetRulesResponse, Error<ClusterFirewallGetRulesError>> {
1370    // add a prefix to parameters to efficiently prevent name collisions
1371    let p_path_group = group;
1372
1373    let uri_str = format!("{}/cluster/firewall/groups/{group}", configuration.base_path, group=crate::apis::urlencode(p_path_group));
1374    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1375
1376    if let Some(ref user_agent) = configuration.user_agent {
1377        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1378    }
1379    if let Some(ref apikey) = configuration.api_key {
1380        let key = apikey.key.clone();
1381        let value = match apikey.prefix {
1382            Some(ref prefix) => format!("{} {}", prefix, key),
1383            None => key,
1384        };
1385        req_builder = req_builder.header("Authorization", value);
1386    };
1387    if let Some(ref apikey) = configuration.api_key {
1388        let key = apikey.key.clone();
1389        let value = match apikey.prefix {
1390            Some(ref prefix) => format!("{} {}", prefix, key),
1391            None => key,
1392        };
1393        req_builder = req_builder.header("CSRFPreventionToken", value);
1394    };
1395
1396    let req = req_builder.build()?;
1397    let resp = configuration.client.execute(req).await?;
1398
1399    let status = resp.status();
1400    let content_type = resp
1401        .headers()
1402        .get("content-type")
1403        .and_then(|v| v.to_str().ok())
1404        .unwrap_or("application/octet-stream");
1405    let content_type = super::ContentType::from(content_type);
1406
1407    if !status.is_client_error() && !status.is_server_error() {
1408        let content = resp.text().await?;
1409        match content_type {
1410            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1411            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetRulesResponse`"))),
1412            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetRulesResponse`")))),
1413        }
1414    } else {
1415        let content = resp.text().await?;
1416        let entity: Option<ClusterFirewallGetRulesError> = serde_json::from_str(&content).ok();
1417        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1418    }
1419}
1420
1421/// List rules.
1422pub async fn cluster_firewall_get_rules_get_rules(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallGetRulesGetRulesResponse, Error<ClusterFirewallGetRulesGetRulesError>> {
1423
1424    let uri_str = format!("{}/cluster/firewall/rules", configuration.base_path);
1425    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1426
1427    if let Some(ref user_agent) = configuration.user_agent {
1428        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1429    }
1430    if let Some(ref apikey) = configuration.api_key {
1431        let key = apikey.key.clone();
1432        let value = match apikey.prefix {
1433            Some(ref prefix) => format!("{} {}", prefix, key),
1434            None => key,
1435        };
1436        req_builder = req_builder.header("Authorization", value);
1437    };
1438    if let Some(ref apikey) = configuration.api_key {
1439        let key = apikey.key.clone();
1440        let value = match apikey.prefix {
1441            Some(ref prefix) => format!("{} {}", prefix, key),
1442            None => key,
1443        };
1444        req_builder = req_builder.header("CSRFPreventionToken", value);
1445    };
1446
1447    let req = req_builder.build()?;
1448    let resp = configuration.client.execute(req).await?;
1449
1450    let status = resp.status();
1451    let content_type = resp
1452        .headers()
1453        .get("content-type")
1454        .and_then(|v| v.to_str().ok())
1455        .unwrap_or("application/octet-stream");
1456    let content_type = super::ContentType::from(content_type);
1457
1458    if !status.is_client_error() && !status.is_server_error() {
1459        let content = resp.text().await?;
1460        match content_type {
1461            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1462            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallGetRulesGetRulesResponse`"))),
1463            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallGetRulesGetRulesResponse`")))),
1464        }
1465    } else {
1466        let content = resp.text().await?;
1467        let entity: Option<ClusterFirewallGetRulesGetRulesError> = serde_json::from_str(&content).ok();
1468        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1469    }
1470}
1471
1472/// List IPSets
1473pub async fn cluster_firewall_ipset_index(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallIpsetIndexResponse, Error<ClusterFirewallIpsetIndexError>> {
1474
1475    let uri_str = format!("{}/cluster/firewall/ipset", configuration.base_path);
1476    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1477
1478    if let Some(ref user_agent) = configuration.user_agent {
1479        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1480    }
1481    if let Some(ref apikey) = configuration.api_key {
1482        let key = apikey.key.clone();
1483        let value = match apikey.prefix {
1484            Some(ref prefix) => format!("{} {}", prefix, key),
1485            None => key,
1486        };
1487        req_builder = req_builder.header("Authorization", value);
1488    };
1489    if let Some(ref apikey) = configuration.api_key {
1490        let key = apikey.key.clone();
1491        let value = match apikey.prefix {
1492            Some(ref prefix) => format!("{} {}", prefix, key),
1493            None => key,
1494        };
1495        req_builder = req_builder.header("CSRFPreventionToken", value);
1496    };
1497
1498    let req = req_builder.build()?;
1499    let resp = configuration.client.execute(req).await?;
1500
1501    let status = resp.status();
1502    let content_type = resp
1503        .headers()
1504        .get("content-type")
1505        .and_then(|v| v.to_str().ok())
1506        .unwrap_or("application/octet-stream");
1507    let content_type = super::ContentType::from(content_type);
1508
1509    if !status.is_client_error() && !status.is_server_error() {
1510        let content = resp.text().await?;
1511        match content_type {
1512            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1513            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallIpsetIndexResponse`"))),
1514            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallIpsetIndexResponse`")))),
1515        }
1516    } else {
1517        let content = resp.text().await?;
1518        let entity: Option<ClusterFirewallIpsetIndexError> = serde_json::from_str(&content).ok();
1519        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1520    }
1521}
1522
1523/// List security groups.
1524pub async fn cluster_firewall_list_security_groups(configuration: &configuration::Configuration, ) -> Result<models::ClusterFirewallListSecurityGroupsResponse, Error<ClusterFirewallListSecurityGroupsError>> {
1525
1526    let uri_str = format!("{}/cluster/firewall/groups", configuration.base_path);
1527    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1528
1529    if let Some(ref user_agent) = configuration.user_agent {
1530        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1531    }
1532    if let Some(ref apikey) = configuration.api_key {
1533        let key = apikey.key.clone();
1534        let value = match apikey.prefix {
1535            Some(ref prefix) => format!("{} {}", prefix, key),
1536            None => key,
1537        };
1538        req_builder = req_builder.header("Authorization", value);
1539    };
1540    if let Some(ref apikey) = configuration.api_key {
1541        let key = apikey.key.clone();
1542        let value = match apikey.prefix {
1543            Some(ref prefix) => format!("{} {}", prefix, key),
1544            None => key,
1545        };
1546        req_builder = req_builder.header("CSRFPreventionToken", value);
1547    };
1548
1549    let req = req_builder.build()?;
1550    let resp = configuration.client.execute(req).await?;
1551
1552    let status = resp.status();
1553    let content_type = resp
1554        .headers()
1555        .get("content-type")
1556        .and_then(|v| v.to_str().ok())
1557        .unwrap_or("application/octet-stream");
1558    let content_type = super::ContentType::from(content_type);
1559
1560    if !status.is_client_error() && !status.is_server_error() {
1561        let content = resp.text().await?;
1562        match content_type {
1563            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1564            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallListSecurityGroupsResponse`"))),
1565            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallListSecurityGroupsResponse`")))),
1566        }
1567    } else {
1568        let content = resp.text().await?;
1569        let entity: Option<ClusterFirewallListSecurityGroupsError> = serde_json::from_str(&content).ok();
1570        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1571    }
1572}
1573
1574/// Read alias.
1575pub async fn cluster_firewall_read_alias(configuration: &configuration::Configuration, name: &str) -> Result<models::ClusterFirewallReadAliasResponse, Error<ClusterFirewallReadAliasError>> {
1576    // add a prefix to parameters to efficiently prevent name collisions
1577    let p_path_name = name;
1578
1579    let uri_str = format!("{}/cluster/firewall/aliases/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
1580    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1581
1582    if let Some(ref user_agent) = configuration.user_agent {
1583        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1584    }
1585    if let Some(ref apikey) = configuration.api_key {
1586        let key = apikey.key.clone();
1587        let value = match apikey.prefix {
1588            Some(ref prefix) => format!("{} {}", prefix, key),
1589            None => key,
1590        };
1591        req_builder = req_builder.header("Authorization", value);
1592    };
1593    if let Some(ref apikey) = configuration.api_key {
1594        let key = apikey.key.clone();
1595        let value = match apikey.prefix {
1596            Some(ref prefix) => format!("{} {}", prefix, key),
1597            None => key,
1598        };
1599        req_builder = req_builder.header("CSRFPreventionToken", value);
1600    };
1601
1602    let req = req_builder.build()?;
1603    let resp = configuration.client.execute(req).await?;
1604
1605    let status = resp.status();
1606    let content_type = resp
1607        .headers()
1608        .get("content-type")
1609        .and_then(|v| v.to_str().ok())
1610        .unwrap_or("application/octet-stream");
1611    let content_type = super::ContentType::from(content_type);
1612
1613    if !status.is_client_error() && !status.is_server_error() {
1614        let content = resp.text().await?;
1615        match content_type {
1616            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1617            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallReadAliasResponse`"))),
1618            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallReadAliasResponse`")))),
1619        }
1620    } else {
1621        let content = resp.text().await?;
1622        let entity: Option<ClusterFirewallReadAliasError> = serde_json::from_str(&content).ok();
1623        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1624    }
1625}
1626
1627/// Read IP or Network settings from IPSet.
1628pub async fn cluster_firewall_read_ip(configuration: &configuration::Configuration, cidr: &str, name: &str) -> Result<models::ClusterFirewallReadIpResponse, Error<ClusterFirewallReadIpError>> {
1629    // add a prefix to parameters to efficiently prevent name collisions
1630    let p_path_cidr = cidr;
1631    let p_path_name = name;
1632
1633    let uri_str = format!("{}/cluster/firewall/ipset/{name}/{cidr}", configuration.base_path, cidr=crate::apis::urlencode(p_path_cidr), name=crate::apis::urlencode(p_path_name));
1634    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1635
1636    if let Some(ref user_agent) = configuration.user_agent {
1637        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1638    }
1639    if let Some(ref apikey) = configuration.api_key {
1640        let key = apikey.key.clone();
1641        let value = match apikey.prefix {
1642            Some(ref prefix) => format!("{} {}", prefix, key),
1643            None => key,
1644        };
1645        req_builder = req_builder.header("Authorization", value);
1646    };
1647    if let Some(ref apikey) = configuration.api_key {
1648        let key = apikey.key.clone();
1649        let value = match apikey.prefix {
1650            Some(ref prefix) => format!("{} {}", prefix, key),
1651            None => key,
1652        };
1653        req_builder = req_builder.header("CSRFPreventionToken", value);
1654    };
1655
1656    let req = req_builder.build()?;
1657    let resp = configuration.client.execute(req).await?;
1658
1659    let status = resp.status();
1660    let content_type = resp
1661        .headers()
1662        .get("content-type")
1663        .and_then(|v| v.to_str().ok())
1664        .unwrap_or("application/octet-stream");
1665    let content_type = super::ContentType::from(content_type);
1666
1667    if !status.is_client_error() && !status.is_server_error() {
1668        let content = resp.text().await?;
1669        match content_type {
1670            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1671            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallReadIpResponse`"))),
1672            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallReadIpResponse`")))),
1673        }
1674    } else {
1675        let content = resp.text().await?;
1676        let entity: Option<ClusterFirewallReadIpError> = serde_json::from_str(&content).ok();
1677        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1678    }
1679}
1680
1681/// Lists possible IPSet/Alias reference which are allowed in source/dest properties.
1682pub async fn cluster_firewall_refs(configuration: &configuration::Configuration, r#type: Option<models::PveTypeTypeEnum>) -> Result<models::ClusterFirewallRefsResponse, Error<ClusterFirewallRefsError>> {
1683    // add a prefix to parameters to efficiently prevent name collisions
1684    let p_query_type = r#type;
1685
1686    let uri_str = format!("{}/cluster/firewall/refs", configuration.base_path);
1687    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1688
1689    if let Some(ref param_value) = p_query_type {
1690        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
1691    }
1692    if let Some(ref user_agent) = configuration.user_agent {
1693        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1694    }
1695    if let Some(ref apikey) = configuration.api_key {
1696        let key = apikey.key.clone();
1697        let value = match apikey.prefix {
1698            Some(ref prefix) => format!("{} {}", prefix, key),
1699            None => key,
1700        };
1701        req_builder = req_builder.header("Authorization", value);
1702    };
1703    if let Some(ref apikey) = configuration.api_key {
1704        let key = apikey.key.clone();
1705        let value = match apikey.prefix {
1706            Some(ref prefix) => format!("{} {}", prefix, key),
1707            None => key,
1708        };
1709        req_builder = req_builder.header("CSRFPreventionToken", value);
1710    };
1711
1712    let req = req_builder.build()?;
1713    let resp = configuration.client.execute(req).await?;
1714
1715    let status = resp.status();
1716    let content_type = resp
1717        .headers()
1718        .get("content-type")
1719        .and_then(|v| v.to_str().ok())
1720        .unwrap_or("application/octet-stream");
1721    let content_type = super::ContentType::from(content_type);
1722
1723    if !status.is_client_error() && !status.is_server_error() {
1724        let content = resp.text().await?;
1725        match content_type {
1726            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1727            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallRefsResponse`"))),
1728            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallRefsResponse`")))),
1729        }
1730    } else {
1731        let content = resp.text().await?;
1732        let entity: Option<ClusterFirewallRefsError> = serde_json::from_str(&content).ok();
1733        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1734    }
1735}
1736
1737/// Remove IP or Network alias.
1738pub async fn cluster_firewall_remove_alias(configuration: &configuration::Configuration, name: &str, digest: Option<&str>) -> Result<models::ClusterFirewallRemoveAliasResponse, Error<ClusterFirewallRemoveAliasError>> {
1739    // add a prefix to parameters to efficiently prevent name collisions
1740    let p_path_name = name;
1741    let p_query_digest = digest;
1742
1743    let uri_str = format!("{}/cluster/firewall/aliases/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
1744    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1745
1746    if let Some(ref param_value) = p_query_digest {
1747        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
1748    }
1749    if let Some(ref user_agent) = configuration.user_agent {
1750        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1751    }
1752    if let Some(ref apikey) = configuration.api_key {
1753        let key = apikey.key.clone();
1754        let value = match apikey.prefix {
1755            Some(ref prefix) => format!("{} {}", prefix, key),
1756            None => key,
1757        };
1758        req_builder = req_builder.header("Authorization", value);
1759    };
1760    if let Some(ref apikey) = configuration.api_key {
1761        let key = apikey.key.clone();
1762        let value = match apikey.prefix {
1763            Some(ref prefix) => format!("{} {}", prefix, key),
1764            None => key,
1765        };
1766        req_builder = req_builder.header("CSRFPreventionToken", value);
1767    };
1768
1769    let req = req_builder.build()?;
1770    let resp = configuration.client.execute(req).await?;
1771
1772    let status = resp.status();
1773    let content_type = resp
1774        .headers()
1775        .get("content-type")
1776        .and_then(|v| v.to_str().ok())
1777        .unwrap_or("application/octet-stream");
1778    let content_type = super::ContentType::from(content_type);
1779
1780    if !status.is_client_error() && !status.is_server_error() {
1781        let content = resp.text().await?;
1782        match content_type {
1783            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1784            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallRemoveAliasResponse`"))),
1785            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallRemoveAliasResponse`")))),
1786        }
1787    } else {
1788        let content = resp.text().await?;
1789        let entity: Option<ClusterFirewallRemoveAliasError> = serde_json::from_str(&content).ok();
1790        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1791    }
1792}
1793
1794/// Remove IP or Network from IPSet.
1795pub async fn cluster_firewall_remove_ip(configuration: &configuration::Configuration, cidr: &str, name: &str, digest: Option<&str>) -> Result<models::ClusterFirewallRemoveIpResponse, Error<ClusterFirewallRemoveIpError>> {
1796    // add a prefix to parameters to efficiently prevent name collisions
1797    let p_path_cidr = cidr;
1798    let p_path_name = name;
1799    let p_query_digest = digest;
1800
1801    let uri_str = format!("{}/cluster/firewall/ipset/{name}/{cidr}", configuration.base_path, cidr=crate::apis::urlencode(p_path_cidr), name=crate::apis::urlencode(p_path_name));
1802    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1803
1804    if let Some(ref param_value) = p_query_digest {
1805        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
1806    }
1807    if let Some(ref user_agent) = configuration.user_agent {
1808        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1809    }
1810    if let Some(ref apikey) = configuration.api_key {
1811        let key = apikey.key.clone();
1812        let value = match apikey.prefix {
1813            Some(ref prefix) => format!("{} {}", prefix, key),
1814            None => key,
1815        };
1816        req_builder = req_builder.header("Authorization", value);
1817    };
1818    if let Some(ref apikey) = configuration.api_key {
1819        let key = apikey.key.clone();
1820        let value = match apikey.prefix {
1821            Some(ref prefix) => format!("{} {}", prefix, key),
1822            None => key,
1823        };
1824        req_builder = req_builder.header("CSRFPreventionToken", value);
1825    };
1826
1827    let req = req_builder.build()?;
1828    let resp = configuration.client.execute(req).await?;
1829
1830    let status = resp.status();
1831    let content_type = resp
1832        .headers()
1833        .get("content-type")
1834        .and_then(|v| v.to_str().ok())
1835        .unwrap_or("application/octet-stream");
1836    let content_type = super::ContentType::from(content_type);
1837
1838    if !status.is_client_error() && !status.is_server_error() {
1839        let content = resp.text().await?;
1840        match content_type {
1841            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1842            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallRemoveIpResponse`"))),
1843            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallRemoveIpResponse`")))),
1844        }
1845    } else {
1846        let content = resp.text().await?;
1847        let entity: Option<ClusterFirewallRemoveIpError> = serde_json::from_str(&content).ok();
1848        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1849    }
1850}
1851
1852/// Set Firewall options.
1853pub async fn cluster_firewall_set_options(configuration: &configuration::Configuration, cluster_firewall_set_options_request: Option<models::ClusterFirewallSetOptionsRequest>) -> Result<models::ClusterFirewallSetOptionsResponse, Error<ClusterFirewallSetOptionsError>> {
1854    // add a prefix to parameters to efficiently prevent name collisions
1855    let p_body_cluster_firewall_set_options_request = cluster_firewall_set_options_request;
1856
1857    let uri_str = format!("{}/cluster/firewall/options", configuration.base_path);
1858    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1859
1860    if let Some(ref user_agent) = configuration.user_agent {
1861        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1862    }
1863    if let Some(ref apikey) = configuration.api_key {
1864        let key = apikey.key.clone();
1865        let value = match apikey.prefix {
1866            Some(ref prefix) => format!("{} {}", prefix, key),
1867            None => key,
1868        };
1869        req_builder = req_builder.header("Authorization", value);
1870    };
1871    if let Some(ref apikey) = configuration.api_key {
1872        let key = apikey.key.clone();
1873        let value = match apikey.prefix {
1874            Some(ref prefix) => format!("{} {}", prefix, key),
1875            None => key,
1876        };
1877        req_builder = req_builder.header("CSRFPreventionToken", value);
1878    };
1879    req_builder = req_builder.json(&p_body_cluster_firewall_set_options_request);
1880
1881    let req = req_builder.build()?;
1882    let resp = configuration.client.execute(req).await?;
1883
1884    let status = resp.status();
1885    let content_type = resp
1886        .headers()
1887        .get("content-type")
1888        .and_then(|v| v.to_str().ok())
1889        .unwrap_or("application/octet-stream");
1890    let content_type = super::ContentType::from(content_type);
1891
1892    if !status.is_client_error() && !status.is_server_error() {
1893        let content = resp.text().await?;
1894        match content_type {
1895            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1896            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallSetOptionsResponse`"))),
1897            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallSetOptionsResponse`")))),
1898        }
1899    } else {
1900        let content = resp.text().await?;
1901        let entity: Option<ClusterFirewallSetOptionsError> = serde_json::from_str(&content).ok();
1902        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1903    }
1904}
1905
1906/// Update IP or Network alias.
1907pub async fn cluster_firewall_update_alias(configuration: &configuration::Configuration, name: &str, cluster_firewall_update_alias_request: models::ClusterFirewallUpdateAliasRequest) -> Result<models::ClusterFirewallUpdateAliasResponse, Error<ClusterFirewallUpdateAliasError>> {
1908    // add a prefix to parameters to efficiently prevent name collisions
1909    let p_path_name = name;
1910    let p_body_cluster_firewall_update_alias_request = cluster_firewall_update_alias_request;
1911
1912    let uri_str = format!("{}/cluster/firewall/aliases/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
1913    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1914
1915    if let Some(ref user_agent) = configuration.user_agent {
1916        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1917    }
1918    if let Some(ref apikey) = configuration.api_key {
1919        let key = apikey.key.clone();
1920        let value = match apikey.prefix {
1921            Some(ref prefix) => format!("{} {}", prefix, key),
1922            None => key,
1923        };
1924        req_builder = req_builder.header("Authorization", value);
1925    };
1926    if let Some(ref apikey) = configuration.api_key {
1927        let key = apikey.key.clone();
1928        let value = match apikey.prefix {
1929            Some(ref prefix) => format!("{} {}", prefix, key),
1930            None => key,
1931        };
1932        req_builder = req_builder.header("CSRFPreventionToken", value);
1933    };
1934    req_builder = req_builder.json(&p_body_cluster_firewall_update_alias_request);
1935
1936    let req = req_builder.build()?;
1937    let resp = configuration.client.execute(req).await?;
1938
1939    let status = resp.status();
1940    let content_type = resp
1941        .headers()
1942        .get("content-type")
1943        .and_then(|v| v.to_str().ok())
1944        .unwrap_or("application/octet-stream");
1945    let content_type = super::ContentType::from(content_type);
1946
1947    if !status.is_client_error() && !status.is_server_error() {
1948        let content = resp.text().await?;
1949        match content_type {
1950            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1951            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallUpdateAliasResponse`"))),
1952            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallUpdateAliasResponse`")))),
1953        }
1954    } else {
1955        let content = resp.text().await?;
1956        let entity: Option<ClusterFirewallUpdateAliasError> = serde_json::from_str(&content).ok();
1957        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1958    }
1959}
1960
1961/// Update IP or Network settings
1962pub async fn cluster_firewall_update_ip(configuration: &configuration::Configuration, cidr: &str, name: &str, cluster_firewall_update_ip_request: Option<models::ClusterFirewallUpdateIpRequest>) -> Result<models::ClusterFirewallUpdateIpResponse, Error<ClusterFirewallUpdateIpError>> {
1963    // add a prefix to parameters to efficiently prevent name collisions
1964    let p_path_cidr = cidr;
1965    let p_path_name = name;
1966    let p_body_cluster_firewall_update_ip_request = cluster_firewall_update_ip_request;
1967
1968    let uri_str = format!("{}/cluster/firewall/ipset/{name}/{cidr}", configuration.base_path, cidr=crate::apis::urlencode(p_path_cidr), name=crate::apis::urlencode(p_path_name));
1969    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1970
1971    if let Some(ref user_agent) = configuration.user_agent {
1972        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1973    }
1974    if let Some(ref apikey) = configuration.api_key {
1975        let key = apikey.key.clone();
1976        let value = match apikey.prefix {
1977            Some(ref prefix) => format!("{} {}", prefix, key),
1978            None => key,
1979        };
1980        req_builder = req_builder.header("Authorization", value);
1981    };
1982    if let Some(ref apikey) = configuration.api_key {
1983        let key = apikey.key.clone();
1984        let value = match apikey.prefix {
1985            Some(ref prefix) => format!("{} {}", prefix, key),
1986            None => key,
1987        };
1988        req_builder = req_builder.header("CSRFPreventionToken", value);
1989    };
1990    req_builder = req_builder.json(&p_body_cluster_firewall_update_ip_request);
1991
1992    let req = req_builder.build()?;
1993    let resp = configuration.client.execute(req).await?;
1994
1995    let status = resp.status();
1996    let content_type = resp
1997        .headers()
1998        .get("content-type")
1999        .and_then(|v| v.to_str().ok())
2000        .unwrap_or("application/octet-stream");
2001    let content_type = super::ContentType::from(content_type);
2002
2003    if !status.is_client_error() && !status.is_server_error() {
2004        let content = resp.text().await?;
2005        match content_type {
2006            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2007            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallUpdateIpResponse`"))),
2008            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallUpdateIpResponse`")))),
2009        }
2010    } else {
2011        let content = resp.text().await?;
2012        let entity: Option<ClusterFirewallUpdateIpError> = serde_json::from_str(&content).ok();
2013        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2014    }
2015}
2016
2017/// Modify rule data.
2018pub async fn cluster_firewall_update_rule(configuration: &configuration::Configuration, group: &str, pos: i64, cluster_firewall_update_rule_request: Option<models::ClusterFirewallUpdateRuleRequest>) -> Result<models::ClusterFirewallUpdateRuleResponse, Error<ClusterFirewallUpdateRuleError>> {
2019    // add a prefix to parameters to efficiently prevent name collisions
2020    let p_path_group = group;
2021    let p_path_pos = pos;
2022    let p_body_cluster_firewall_update_rule_request = cluster_firewall_update_rule_request;
2023
2024    let uri_str = format!("{}/cluster/firewall/groups/{group}/{pos}", configuration.base_path, group=crate::apis::urlencode(p_path_group), pos=p_path_pos);
2025    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2026
2027    if let Some(ref user_agent) = configuration.user_agent {
2028        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2029    }
2030    if let Some(ref apikey) = configuration.api_key {
2031        let key = apikey.key.clone();
2032        let value = match apikey.prefix {
2033            Some(ref prefix) => format!("{} {}", prefix, key),
2034            None => key,
2035        };
2036        req_builder = req_builder.header("Authorization", value);
2037    };
2038    if let Some(ref apikey) = configuration.api_key {
2039        let key = apikey.key.clone();
2040        let value = match apikey.prefix {
2041            Some(ref prefix) => format!("{} {}", prefix, key),
2042            None => key,
2043        };
2044        req_builder = req_builder.header("CSRFPreventionToken", value);
2045    };
2046    req_builder = req_builder.json(&p_body_cluster_firewall_update_rule_request);
2047
2048    let req = req_builder.build()?;
2049    let resp = configuration.client.execute(req).await?;
2050
2051    let status = resp.status();
2052    let content_type = resp
2053        .headers()
2054        .get("content-type")
2055        .and_then(|v| v.to_str().ok())
2056        .unwrap_or("application/octet-stream");
2057    let content_type = super::ContentType::from(content_type);
2058
2059    if !status.is_client_error() && !status.is_server_error() {
2060        let content = resp.text().await?;
2061        match content_type {
2062            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2063            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallUpdateRuleResponse`"))),
2064            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallUpdateRuleResponse`")))),
2065        }
2066    } else {
2067        let content = resp.text().await?;
2068        let entity: Option<ClusterFirewallUpdateRuleError> = serde_json::from_str(&content).ok();
2069        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2070    }
2071}
2072
2073/// Modify rule data.
2074pub async fn cluster_firewall_update_rules(configuration: &configuration::Configuration, pos: i64, cluster_firewall_update_rule_request: Option<models::ClusterFirewallUpdateRuleRequest>) -> Result<models::ClusterFirewallUpdateRulesResponse, Error<ClusterFirewallUpdateRulesError>> {
2075    // add a prefix to parameters to efficiently prevent name collisions
2076    let p_path_pos = pos;
2077    let p_body_cluster_firewall_update_rule_request = cluster_firewall_update_rule_request;
2078
2079    let uri_str = format!("{}/cluster/firewall/rules/{pos}", configuration.base_path, pos=p_path_pos);
2080    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2081
2082    if let Some(ref user_agent) = configuration.user_agent {
2083        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2084    }
2085    if let Some(ref apikey) = configuration.api_key {
2086        let key = apikey.key.clone();
2087        let value = match apikey.prefix {
2088            Some(ref prefix) => format!("{} {}", prefix, key),
2089            None => key,
2090        };
2091        req_builder = req_builder.header("Authorization", value);
2092    };
2093    if let Some(ref apikey) = configuration.api_key {
2094        let key = apikey.key.clone();
2095        let value = match apikey.prefix {
2096            Some(ref prefix) => format!("{} {}", prefix, key),
2097            None => key,
2098        };
2099        req_builder = req_builder.header("CSRFPreventionToken", value);
2100    };
2101    req_builder = req_builder.json(&p_body_cluster_firewall_update_rule_request);
2102
2103    let req = req_builder.build()?;
2104    let resp = configuration.client.execute(req).await?;
2105
2106    let status = resp.status();
2107    let content_type = resp
2108        .headers()
2109        .get("content-type")
2110        .and_then(|v| v.to_str().ok())
2111        .unwrap_or("application/octet-stream");
2112    let content_type = super::ContentType::from(content_type);
2113
2114    if !status.is_client_error() && !status.is_server_error() {
2115        let content = resp.text().await?;
2116        match content_type {
2117            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2118            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ClusterFirewallUpdateRulesResponse`"))),
2119            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ClusterFirewallUpdateRulesResponse`")))),
2120        }
2121    } else {
2122        let content = resp.text().await?;
2123        let entity: Option<ClusterFirewallUpdateRulesError> = serde_json::from_str(&content).ok();
2124        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2125    }
2126}
2127
clientapi_pve/apis/cluster_firewall_api.rs

clientapi_pve/apis/
cluster_firewall_api.rs
