1use super::{configuration, Error};
12use crate::apis::ResponseContent;
13
14#[derive(Debug, Clone, Serialize, Deserialize)]
16#[serde(untagged)]
17pub enum AcceptNetPeeringError {
18 Status400(crate::models::ErrorResponse),
19 Status401(crate::models::ErrorResponse),
20 Status409(crate::models::ErrorResponse),
21 Status500(crate::models::ErrorResponse),
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum CreateNetPeeringError {
29 Status400(crate::models::ErrorResponse),
30 Status401(crate::models::ErrorResponse),
31 Status500(crate::models::ErrorResponse),
32 UnknownValue(serde_json::Value),
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum DeleteNetPeeringError {
39 Status400(crate::models::ErrorResponse),
40 Status401(crate::models::ErrorResponse),
41 Status409(crate::models::ErrorResponse),
42 Status500(crate::models::ErrorResponse),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ReadNetPeeringsError {
50 Status400(crate::models::ErrorResponse),
51 Status401(crate::models::ErrorResponse),
52 Status500(crate::models::ErrorResponse),
53 UnknownValue(serde_json::Value),
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(untagged)]
59pub enum RejectNetPeeringError {
60 Status400(crate::models::ErrorResponse),
61 Status401(crate::models::ErrorResponse),
62 Status409(crate::models::ErrorResponse),
63 Status500(crate::models::ErrorResponse),
64 UnknownValue(serde_json::Value),
65}
66
67pub fn accept_net_peering(
69 configuration: &configuration::Configuration,
70 accept_net_peering_request: Option<crate::models::AcceptNetPeeringRequest>,
71) -> Result<crate::models::AcceptNetPeeringResponse, Error<AcceptNetPeeringError>> {
72 let local_var_configuration = configuration;
73
74 let local_var_client = &local_var_configuration.client;
75
76 let local_var_uri_str = format!("{}/AcceptNetPeering", local_var_configuration.base_path);
77 let mut local_var_req_builder =
78 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
79
80 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
81 let local_var_new_headers = match local_var_aws_v4_key.sign(
82 &local_var_uri_str,
83 "POST",
84 &serde_json::to_string(&accept_net_peering_request)
85 .expect("param should serialize to string"),
86 ) {
87 Ok(new_headers) => new_headers,
88 Err(err) => return Err(Error::AWSV4SignatureError(err)),
89 };
90 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
91 local_var_req_builder =
92 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
93 }
94 }
95 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
96 local_var_req_builder =
97 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
98 }
99 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
100 let local_var_key = local_var_apikey.key.clone();
101 let local_var_value = match local_var_apikey.prefix {
102 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
103 None => local_var_key,
104 };
105 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
106 };
107 local_var_req_builder = local_var_req_builder.json(&accept_net_peering_request);
108
109 let local_var_req = local_var_req_builder.build()?;
110 let local_var_resp = local_var_client.execute(local_var_req)?;
111
112 let local_var_status = local_var_resp.status();
113 let local_var_content = local_var_resp.text()?;
114
115 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
116 serde_json::from_str(&local_var_content).map_err(Error::from)
117 } else {
118 let local_var_entity: Option<AcceptNetPeeringError> =
119 serde_json::from_str(&local_var_content).ok();
120 let local_var_error = ResponseContent {
121 status: local_var_status,
122 content: local_var_content,
123 entity: local_var_entity,
124 };
125 Err(Error::ResponseError(local_var_error))
126 }
127}
128
129pub fn create_net_peering(
131 configuration: &configuration::Configuration,
132 create_net_peering_request: Option<crate::models::CreateNetPeeringRequest>,
133) -> Result<crate::models::CreateNetPeeringResponse, Error<CreateNetPeeringError>> {
134 let local_var_configuration = configuration;
135
136 let local_var_client = &local_var_configuration.client;
137
138 let local_var_uri_str = format!("{}/CreateNetPeering", local_var_configuration.base_path);
139 let mut local_var_req_builder =
140 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
141
142 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
143 let local_var_new_headers = match local_var_aws_v4_key.sign(
144 &local_var_uri_str,
145 "POST",
146 &serde_json::to_string(&create_net_peering_request)
147 .expect("param should serialize to string"),
148 ) {
149 Ok(new_headers) => new_headers,
150 Err(err) => return Err(Error::AWSV4SignatureError(err)),
151 };
152 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
153 local_var_req_builder =
154 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
155 }
156 }
157 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
158 local_var_req_builder =
159 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
160 }
161 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
162 let local_var_key = local_var_apikey.key.clone();
163 let local_var_value = match local_var_apikey.prefix {
164 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
165 None => local_var_key,
166 };
167 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
168 };
169 local_var_req_builder = local_var_req_builder.json(&create_net_peering_request);
170
171 let local_var_req = local_var_req_builder.build()?;
172 let local_var_resp = local_var_client.execute(local_var_req)?;
173
174 let local_var_status = local_var_resp.status();
175 let local_var_content = local_var_resp.text()?;
176
177 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
178 serde_json::from_str(&local_var_content).map_err(Error::from)
179 } else {
180 let local_var_entity: Option<CreateNetPeeringError> =
181 serde_json::from_str(&local_var_content).ok();
182 let local_var_error = ResponseContent {
183 status: local_var_status,
184 content: local_var_content,
185 entity: local_var_entity,
186 };
187 Err(Error::ResponseError(local_var_error))
188 }
189}
190
191pub fn delete_net_peering(
193 configuration: &configuration::Configuration,
194 delete_net_peering_request: Option<crate::models::DeleteNetPeeringRequest>,
195) -> Result<crate::models::DeleteNetPeeringResponse, Error<DeleteNetPeeringError>> {
196 let local_var_configuration = configuration;
197
198 let local_var_client = &local_var_configuration.client;
199
200 let local_var_uri_str = format!("{}/DeleteNetPeering", local_var_configuration.base_path);
201 let mut local_var_req_builder =
202 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
203
204 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
205 let local_var_new_headers = match local_var_aws_v4_key.sign(
206 &local_var_uri_str,
207 "POST",
208 &serde_json::to_string(&delete_net_peering_request)
209 .expect("param should serialize to string"),
210 ) {
211 Ok(new_headers) => new_headers,
212 Err(err) => return Err(Error::AWSV4SignatureError(err)),
213 };
214 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
215 local_var_req_builder =
216 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
217 }
218 }
219 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
220 local_var_req_builder =
221 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
222 }
223 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
224 let local_var_key = local_var_apikey.key.clone();
225 let local_var_value = match local_var_apikey.prefix {
226 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
227 None => local_var_key,
228 };
229 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
230 };
231 local_var_req_builder = local_var_req_builder.json(&delete_net_peering_request);
232
233 let local_var_req = local_var_req_builder.build()?;
234 let local_var_resp = local_var_client.execute(local_var_req)?;
235
236 let local_var_status = local_var_resp.status();
237 let local_var_content = local_var_resp.text()?;
238
239 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
240 serde_json::from_str(&local_var_content).map_err(Error::from)
241 } else {
242 let local_var_entity: Option<DeleteNetPeeringError> =
243 serde_json::from_str(&local_var_content).ok();
244 let local_var_error = ResponseContent {
245 status: local_var_status,
246 content: local_var_content,
247 entity: local_var_entity,
248 };
249 Err(Error::ResponseError(local_var_error))
250 }
251}
252
253pub fn read_net_peerings(
255 configuration: &configuration::Configuration,
256 read_net_peerings_request: Option<crate::models::ReadNetPeeringsRequest>,
257) -> Result<crate::models::ReadNetPeeringsResponse, Error<ReadNetPeeringsError>> {
258 let local_var_configuration = configuration;
259
260 let local_var_client = &local_var_configuration.client;
261
262 let local_var_uri_str = format!("{}/ReadNetPeerings", local_var_configuration.base_path);
263 let mut local_var_req_builder =
264 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
265
266 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
267 let local_var_new_headers = match local_var_aws_v4_key.sign(
268 &local_var_uri_str,
269 "POST",
270 &serde_json::to_string(&read_net_peerings_request)
271 .expect("param should serialize to string"),
272 ) {
273 Ok(new_headers) => new_headers,
274 Err(err) => return Err(Error::AWSV4SignatureError(err)),
275 };
276 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
277 local_var_req_builder =
278 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
279 }
280 }
281 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
282 local_var_req_builder =
283 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
284 }
285 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
286 let local_var_key = local_var_apikey.key.clone();
287 let local_var_value = match local_var_apikey.prefix {
288 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
289 None => local_var_key,
290 };
291 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
292 };
293 local_var_req_builder = local_var_req_builder.json(&read_net_peerings_request);
294
295 let local_var_req = local_var_req_builder.build()?;
296 let local_var_resp = local_var_client.execute(local_var_req)?;
297
298 let local_var_status = local_var_resp.status();
299 let local_var_content = local_var_resp.text()?;
300
301 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
302 serde_json::from_str(&local_var_content).map_err(Error::from)
303 } else {
304 let local_var_entity: Option<ReadNetPeeringsError> =
305 serde_json::from_str(&local_var_content).ok();
306 let local_var_error = ResponseContent {
307 status: local_var_status,
308 content: local_var_content,
309 entity: local_var_entity,
310 };
311 Err(Error::ResponseError(local_var_error))
312 }
313}
314
315pub fn reject_net_peering(
317 configuration: &configuration::Configuration,
318 reject_net_peering_request: Option<crate::models::RejectNetPeeringRequest>,
319) -> Result<crate::models::RejectNetPeeringResponse, Error<RejectNetPeeringError>> {
320 let local_var_configuration = configuration;
321
322 let local_var_client = &local_var_configuration.client;
323
324 let local_var_uri_str = format!("{}/RejectNetPeering", local_var_configuration.base_path);
325 let mut local_var_req_builder =
326 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
327
328 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
329 let local_var_new_headers = match local_var_aws_v4_key.sign(
330 &local_var_uri_str,
331 "POST",
332 &serde_json::to_string(&reject_net_peering_request)
333 .expect("param should serialize to string"),
334 ) {
335 Ok(new_headers) => new_headers,
336 Err(err) => return Err(Error::AWSV4SignatureError(err)),
337 };
338 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
339 local_var_req_builder =
340 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
341 }
342 }
343 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
344 local_var_req_builder =
345 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
346 }
347 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
348 let local_var_key = local_var_apikey.key.clone();
349 let local_var_value = match local_var_apikey.prefix {
350 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
351 None => local_var_key,
352 };
353 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
354 };
355 local_var_req_builder = local_var_req_builder.json(&reject_net_peering_request);
356
357 let local_var_req = local_var_req_builder.build()?;
358 let local_var_resp = local_var_client.execute(local_var_req)?;
359
360 let local_var_status = local_var_resp.status();
361 let local_var_content = local_var_resp.text()?;
362
363 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
364 serde_json::from_str(&local_var_content).map_err(Error::from)
365 } else {
366 let local_var_entity: Option<RejectNetPeeringError> =
367 serde_json::from_str(&local_var_content).ok();
368 let local_var_error = ResponseContent {
369 status: local_var_status,
370 content: local_var_content,
371 entity: local_var_entity,
372 };
373 Err(Error::ResponseError(local_var_error))
374 }
375}