1use reqwest;
10
11use crate::apis::ResponseContent;
12use super::{Error, configuration};
13
14#[derive(Clone, Debug, Default)]
16pub struct CreateLogAwsS3Params {
17 pub service_id: String,
19 pub version_id: i32,
21 pub name: Option<String>,
23 pub placement: Option<String>,
25 pub response_condition: Option<String>,
27 pub format: Option<String>,
29 pub format_version: Option<i32>,
31 pub message_type: Option<String>,
33 pub timestamp_format: Option<String>,
35 pub compression_codec: Option<String>,
37 pub period: Option<i32>,
39 pub gzip_level: Option<i32>,
41 pub access_key: Option<String>,
43 pub acl: Option<String>,
45 pub bucket_name: Option<String>,
47 pub domain: Option<String>,
49 pub iam_role: Option<String>,
51 pub path: Option<String>,
53 pub public_key: Option<String>,
55 pub redundancy: Option<String>,
57 pub secret_key: Option<String>,
59 pub server_side_encryption_kms_key_id: Option<String>,
61 pub server_side_encryption: Option<String>,
63 pub file_max_bytes: Option<i32>
65}
66
67#[derive(Clone, Debug, Default)]
69pub struct DeleteLogAwsS3Params {
70 pub service_id: String,
72 pub version_id: i32,
74 pub logging_s3_name: String
76}
77
78#[derive(Clone, Debug, Default)]
80pub struct GetLogAwsS3Params {
81 pub service_id: String,
83 pub version_id: i32,
85 pub logging_s3_name: String
87}
88
89#[derive(Clone, Debug, Default)]
91pub struct ListLogAwsS3Params {
92 pub service_id: String,
94 pub version_id: i32
96}
97
98#[derive(Clone, Debug, Default)]
100pub struct UpdateLogAwsS3Params {
101 pub service_id: String,
103 pub version_id: i32,
105 pub logging_s3_name: String,
107 pub name: Option<String>,
109 pub placement: Option<String>,
111 pub response_condition: Option<String>,
113 pub format: Option<String>,
115 pub format_version: Option<i32>,
117 pub message_type: Option<String>,
119 pub timestamp_format: Option<String>,
121 pub compression_codec: Option<String>,
123 pub period: Option<i32>,
125 pub gzip_level: Option<i32>,
127 pub access_key: Option<String>,
129 pub acl: Option<String>,
131 pub bucket_name: Option<String>,
133 pub domain: Option<String>,
135 pub iam_role: Option<String>,
137 pub path: Option<String>,
139 pub public_key: Option<String>,
141 pub redundancy: Option<String>,
143 pub secret_key: Option<String>,
145 pub server_side_encryption_kms_key_id: Option<String>,
147 pub server_side_encryption: Option<String>,
149 pub file_max_bytes: Option<i32>
151}
152
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum CreateLogAwsS3Error {
158 UnknownValue(serde_json::Value),
159}
160
161#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(untagged)]
164pub enum DeleteLogAwsS3Error {
165 UnknownValue(serde_json::Value),
166}
167
168#[derive(Debug, Clone, Serialize, Deserialize)]
170#[serde(untagged)]
171pub enum GetLogAwsS3Error {
172 UnknownValue(serde_json::Value),
173}
174
175#[derive(Debug, Clone, Serialize, Deserialize)]
177#[serde(untagged)]
178pub enum ListLogAwsS3Error {
179 UnknownValue(serde_json::Value),
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
184#[serde(untagged)]
185pub enum UpdateLogAwsS3Error {
186 UnknownValue(serde_json::Value),
187}
188
189
190pub async fn create_log_aws_s3(configuration: &mut configuration::Configuration, params: CreateLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<CreateLogAwsS3Error>> {
192 let local_var_configuration = configuration;
193
194 let service_id = params.service_id;
196 let version_id = params.version_id;
197 let name = params.name;
198 let placement = params.placement;
199 let response_condition = params.response_condition;
200 let format = params.format;
201 let format_version = params.format_version;
202 let message_type = params.message_type;
203 let timestamp_format = params.timestamp_format;
204 let compression_codec = params.compression_codec;
205 let period = params.period;
206 let gzip_level = params.gzip_level;
207 let access_key = params.access_key;
208 let acl = params.acl;
209 let bucket_name = params.bucket_name;
210 let domain = params.domain;
211 let iam_role = params.iam_role;
212 let path = params.path;
213 let public_key = params.public_key;
214 let redundancy = params.redundancy;
215 let secret_key = params.secret_key;
216 let server_side_encryption_kms_key_id = params.server_side_encryption_kms_key_id;
217 let server_side_encryption = params.server_side_encryption;
218 let file_max_bytes = params.file_max_bytes;
219
220
221 let local_var_client = &local_var_configuration.client;
222
223 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
224 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
225
226 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
227 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
228 }
229 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
230 let local_var_key = local_var_apikey.key.clone();
231 let local_var_value = match local_var_apikey.prefix {
232 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
233 None => local_var_key,
234 };
235 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
236 };
237 let mut local_var_form_params = std::collections::HashMap::new();
238 if let Some(local_var_param_value) = name {
239 local_var_form_params.insert("name", local_var_param_value.to_string());
240 }
241 if let Some(local_var_param_value) = placement {
242 local_var_form_params.insert("placement", local_var_param_value.to_string());
243 }
244 if let Some(local_var_param_value) = response_condition {
245 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
246 }
247 if let Some(local_var_param_value) = format {
248 local_var_form_params.insert("format", local_var_param_value.to_string());
249 }
250 if let Some(local_var_param_value) = format_version {
251 local_var_form_params.insert("format_version", local_var_param_value.to_string());
252 }
253 if let Some(local_var_param_value) = message_type {
254 local_var_form_params.insert("message_type", local_var_param_value.to_string());
255 }
256 if let Some(local_var_param_value) = timestamp_format {
257 local_var_form_params.insert("timestamp_format", local_var_param_value.to_string());
258 }
259 if let Some(local_var_param_value) = compression_codec {
260 local_var_form_params.insert("compression_codec", local_var_param_value.to_string());
261 }
262 if let Some(local_var_param_value) = period {
263 local_var_form_params.insert("period", local_var_param_value.to_string());
264 }
265 if let Some(local_var_param_value) = gzip_level {
266 local_var_form_params.insert("gzip_level", local_var_param_value.to_string());
267 }
268 if let Some(local_var_param_value) = access_key {
269 local_var_form_params.insert("access_key", local_var_param_value.to_string());
270 }
271 if let Some(local_var_param_value) = acl {
272 local_var_form_params.insert("acl", local_var_param_value.to_string());
273 }
274 if let Some(local_var_param_value) = bucket_name {
275 local_var_form_params.insert("bucket_name", local_var_param_value.to_string());
276 }
277 if let Some(local_var_param_value) = domain {
278 local_var_form_params.insert("domain", local_var_param_value.to_string());
279 }
280 if let Some(local_var_param_value) = iam_role {
281 local_var_form_params.insert("iam_role", local_var_param_value.to_string());
282 }
283 if let Some(local_var_param_value) = path {
284 local_var_form_params.insert("path", local_var_param_value.to_string());
285 }
286 if let Some(local_var_param_value) = public_key {
287 local_var_form_params.insert("public_key", local_var_param_value.to_string());
288 }
289 if let Some(local_var_param_value) = redundancy {
290 local_var_form_params.insert("redundancy", local_var_param_value.to_string());
291 }
292 if let Some(local_var_param_value) = secret_key {
293 local_var_form_params.insert("secret_key", local_var_param_value.to_string());
294 }
295 if let Some(local_var_param_value) = server_side_encryption_kms_key_id {
296 local_var_form_params.insert("server_side_encryption_kms_key_id", local_var_param_value.to_string());
297 }
298 if let Some(local_var_param_value) = server_side_encryption {
299 local_var_form_params.insert("server_side_encryption", local_var_param_value.to_string());
300 }
301 if let Some(local_var_param_value) = file_max_bytes {
302 local_var_form_params.insert("file_max_bytes", local_var_param_value.to_string());
303 }
304 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
305
306 let local_var_req = local_var_req_builder.build()?;
307 let local_var_resp = local_var_client.execute(local_var_req).await?;
308
309 if "POST" != "GET" && "POST" != "HEAD" {
310 let headers = local_var_resp.headers();
311 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
312 Some(v) => v.to_str().unwrap().parse().unwrap(),
313 None => configuration::DEFAULT_RATELIMIT,
314 };
315 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
316 Some(v) => v.to_str().unwrap().parse().unwrap(),
317 None => 0,
318 };
319 }
320
321 let local_var_status = local_var_resp.status();
322 let local_var_content = local_var_resp.text().await?;
323
324 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
325 serde_json::from_str(&local_var_content).map_err(Error::from)
326 } else {
327 let local_var_entity: Option<CreateLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
328 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
329 Err(Error::ResponseError(local_var_error))
330 }
331}
332
333pub async fn delete_log_aws_s3(configuration: &mut configuration::Configuration, params: DeleteLogAwsS3Params) -> Result<crate::models::InlineResponse200, Error<DeleteLogAwsS3Error>> {
335 let local_var_configuration = configuration;
336
337 let service_id = params.service_id;
339 let version_id = params.version_id;
340 let logging_s3_name = params.logging_s3_name;
341
342
343 let local_var_client = &local_var_configuration.client;
344
345 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
346 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
347
348 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
349 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
350 }
351 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
352 let local_var_key = local_var_apikey.key.clone();
353 let local_var_value = match local_var_apikey.prefix {
354 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
355 None => local_var_key,
356 };
357 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
358 };
359
360 let local_var_req = local_var_req_builder.build()?;
361 let local_var_resp = local_var_client.execute(local_var_req).await?;
362
363 if "DELETE" != "GET" && "DELETE" != "HEAD" {
364 let headers = local_var_resp.headers();
365 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
366 Some(v) => v.to_str().unwrap().parse().unwrap(),
367 None => configuration::DEFAULT_RATELIMIT,
368 };
369 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
370 Some(v) => v.to_str().unwrap().parse().unwrap(),
371 None => 0,
372 };
373 }
374
375 let local_var_status = local_var_resp.status();
376 let local_var_content = local_var_resp.text().await?;
377
378 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
379 serde_json::from_str(&local_var_content).map_err(Error::from)
380 } else {
381 let local_var_entity: Option<DeleteLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
382 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
383 Err(Error::ResponseError(local_var_error))
384 }
385}
386
387pub async fn get_log_aws_s3(configuration: &mut configuration::Configuration, params: GetLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<GetLogAwsS3Error>> {
389 let local_var_configuration = configuration;
390
391 let service_id = params.service_id;
393 let version_id = params.version_id;
394 let logging_s3_name = params.logging_s3_name;
395
396
397 let local_var_client = &local_var_configuration.client;
398
399 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
400 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
401
402 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
403 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
404 }
405 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
406 let local_var_key = local_var_apikey.key.clone();
407 let local_var_value = match local_var_apikey.prefix {
408 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
409 None => local_var_key,
410 };
411 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
412 };
413
414 let local_var_req = local_var_req_builder.build()?;
415 let local_var_resp = local_var_client.execute(local_var_req).await?;
416
417 if "GET" != "GET" && "GET" != "HEAD" {
418 let headers = local_var_resp.headers();
419 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
420 Some(v) => v.to_str().unwrap().parse().unwrap(),
421 None => configuration::DEFAULT_RATELIMIT,
422 };
423 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
424 Some(v) => v.to_str().unwrap().parse().unwrap(),
425 None => 0,
426 };
427 }
428
429 let local_var_status = local_var_resp.status();
430 let local_var_content = local_var_resp.text().await?;
431
432 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
433 serde_json::from_str(&local_var_content).map_err(Error::from)
434 } else {
435 let local_var_entity: Option<GetLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
436 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
437 Err(Error::ResponseError(local_var_error))
438 }
439}
440
441pub async fn list_log_aws_s3(configuration: &mut configuration::Configuration, params: ListLogAwsS3Params) -> Result<Vec<crate::models::LoggingS3Response>, Error<ListLogAwsS3Error>> {
443 let local_var_configuration = configuration;
444
445 let service_id = params.service_id;
447 let version_id = params.version_id;
448
449
450 let local_var_client = &local_var_configuration.client;
451
452 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
453 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
454
455 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
456 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
457 }
458 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
459 let local_var_key = local_var_apikey.key.clone();
460 let local_var_value = match local_var_apikey.prefix {
461 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
462 None => local_var_key,
463 };
464 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
465 };
466
467 let local_var_req = local_var_req_builder.build()?;
468 let local_var_resp = local_var_client.execute(local_var_req).await?;
469
470 if "GET" != "GET" && "GET" != "HEAD" {
471 let headers = local_var_resp.headers();
472 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
473 Some(v) => v.to_str().unwrap().parse().unwrap(),
474 None => configuration::DEFAULT_RATELIMIT,
475 };
476 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
477 Some(v) => v.to_str().unwrap().parse().unwrap(),
478 None => 0,
479 };
480 }
481
482 let local_var_status = local_var_resp.status();
483 let local_var_content = local_var_resp.text().await?;
484
485 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
486 serde_json::from_str(&local_var_content).map_err(Error::from)
487 } else {
488 let local_var_entity: Option<ListLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
489 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
490 Err(Error::ResponseError(local_var_error))
491 }
492}
493
494pub async fn update_log_aws_s3(configuration: &mut configuration::Configuration, params: UpdateLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<UpdateLogAwsS3Error>> {
496 let local_var_configuration = configuration;
497
498 let service_id = params.service_id;
500 let version_id = params.version_id;
501 let logging_s3_name = params.logging_s3_name;
502 let name = params.name;
503 let placement = params.placement;
504 let response_condition = params.response_condition;
505 let format = params.format;
506 let format_version = params.format_version;
507 let message_type = params.message_type;
508 let timestamp_format = params.timestamp_format;
509 let compression_codec = params.compression_codec;
510 let period = params.period;
511 let gzip_level = params.gzip_level;
512 let access_key = params.access_key;
513 let acl = params.acl;
514 let bucket_name = params.bucket_name;
515 let domain = params.domain;
516 let iam_role = params.iam_role;
517 let path = params.path;
518 let public_key = params.public_key;
519 let redundancy = params.redundancy;
520 let secret_key = params.secret_key;
521 let server_side_encryption_kms_key_id = params.server_side_encryption_kms_key_id;
522 let server_side_encryption = params.server_side_encryption;
523 let file_max_bytes = params.file_max_bytes;
524
525
526 let local_var_client = &local_var_configuration.client;
527
528 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
529 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
530
531 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
532 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
533 }
534 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
535 let local_var_key = local_var_apikey.key.clone();
536 let local_var_value = match local_var_apikey.prefix {
537 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
538 None => local_var_key,
539 };
540 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
541 };
542 let mut local_var_form_params = std::collections::HashMap::new();
543 if let Some(local_var_param_value) = name {
544 local_var_form_params.insert("name", local_var_param_value.to_string());
545 }
546 if let Some(local_var_param_value) = placement {
547 local_var_form_params.insert("placement", local_var_param_value.to_string());
548 }
549 if let Some(local_var_param_value) = response_condition {
550 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
551 }
552 if let Some(local_var_param_value) = format {
553 local_var_form_params.insert("format", local_var_param_value.to_string());
554 }
555 if let Some(local_var_param_value) = format_version {
556 local_var_form_params.insert("format_version", local_var_param_value.to_string());
557 }
558 if let Some(local_var_param_value) = message_type {
559 local_var_form_params.insert("message_type", local_var_param_value.to_string());
560 }
561 if let Some(local_var_param_value) = timestamp_format {
562 local_var_form_params.insert("timestamp_format", local_var_param_value.to_string());
563 }
564 if let Some(local_var_param_value) = compression_codec {
565 local_var_form_params.insert("compression_codec", local_var_param_value.to_string());
566 }
567 if let Some(local_var_param_value) = period {
568 local_var_form_params.insert("period", local_var_param_value.to_string());
569 }
570 if let Some(local_var_param_value) = gzip_level {
571 local_var_form_params.insert("gzip_level", local_var_param_value.to_string());
572 }
573 if let Some(local_var_param_value) = access_key {
574 local_var_form_params.insert("access_key", local_var_param_value.to_string());
575 }
576 if let Some(local_var_param_value) = acl {
577 local_var_form_params.insert("acl", local_var_param_value.to_string());
578 }
579 if let Some(local_var_param_value) = bucket_name {
580 local_var_form_params.insert("bucket_name", local_var_param_value.to_string());
581 }
582 if let Some(local_var_param_value) = domain {
583 local_var_form_params.insert("domain", local_var_param_value.to_string());
584 }
585 if let Some(local_var_param_value) = iam_role {
586 local_var_form_params.insert("iam_role", local_var_param_value.to_string());
587 }
588 if let Some(local_var_param_value) = path {
589 local_var_form_params.insert("path", local_var_param_value.to_string());
590 }
591 if let Some(local_var_param_value) = public_key {
592 local_var_form_params.insert("public_key", local_var_param_value.to_string());
593 }
594 if let Some(local_var_param_value) = redundancy {
595 local_var_form_params.insert("redundancy", local_var_param_value.to_string());
596 }
597 if let Some(local_var_param_value) = secret_key {
598 local_var_form_params.insert("secret_key", local_var_param_value.to_string());
599 }
600 if let Some(local_var_param_value) = server_side_encryption_kms_key_id {
601 local_var_form_params.insert("server_side_encryption_kms_key_id", local_var_param_value.to_string());
602 }
603 if let Some(local_var_param_value) = server_side_encryption {
604 local_var_form_params.insert("server_side_encryption", local_var_param_value.to_string());
605 }
606 if let Some(local_var_param_value) = file_max_bytes {
607 local_var_form_params.insert("file_max_bytes", local_var_param_value.to_string());
608 }
609 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
610
611 let local_var_req = local_var_req_builder.build()?;
612 let local_var_resp = local_var_client.execute(local_var_req).await?;
613
614 if "PUT" != "GET" && "PUT" != "HEAD" {
615 let headers = local_var_resp.headers();
616 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
617 Some(v) => v.to_str().unwrap().parse().unwrap(),
618 None => configuration::DEFAULT_RATELIMIT,
619 };
620 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
621 Some(v) => v.to_str().unwrap().parse().unwrap(),
622 None => 0,
623 };
624 }
625
626 let local_var_status = local_var_resp.status();
627 let local_var_content = local_var_resp.text().await?;
628
629 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
630 serde_json::from_str(&local_var_content).map_err(Error::from)
631 } else {
632 let local_var_entity: Option<UpdateLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
633 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
634 Err(Error::ResponseError(local_var_error))
635 }
636}
637