1use reqwest;
12use serde::{de::Error as _, Deserialize, Serialize};
13
14use super::{configuration, ContentType, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum OrganizationsOrganizationIdBillingChangeFrequencyPostError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum OrganizationsOrganizationIdBillingGetError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum OrganizationsOrganizationIdBillingHistoryGetError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum OrganizationsOrganizationIdBillingInvoicesGetError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum OrganizationsOrganizationIdBillingMetadataGetError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum OrganizationsOrganizationIdBillingPaymentMethodGetError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum OrganizationsOrganizationIdBillingPaymentMethodPutError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum OrganizationsOrganizationIdBillingPaymentMethodVerifyBankAccountPostError {
72 UnknownValue(serde_json::Value),
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum OrganizationsOrganizationIdBillingRestartSubscriptionPostError {
80 UnknownValue(serde_json::Value),
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum OrganizationsOrganizationIdBillingSetupBusinessUnitPostError {
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum OrganizationsOrganizationIdBillingTaxInformationGetError {
95 UnknownValue(serde_json::Value),
96}
97
98#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum OrganizationsOrganizationIdBillingTaxInformationPutError {
102 UnknownValue(serde_json::Value),
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum OrganizationsOrganizationIdBillingTransactionsGetError {
109 UnknownValue(serde_json::Value),
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize)]
114#[serde(untagged)]
115pub enum OrganizationsOrganizationIdBillingWarningsGetError {
116 UnknownValue(serde_json::Value),
117}
118
119pub async fn organizations_organization_id_billing_change_frequency_post(
120 configuration: &configuration::Configuration,
121 organization_id: uuid::Uuid,
122 change_plan_frequency_request: Option<models::ChangePlanFrequencyRequest>,
123) -> Result<(), Error<OrganizationsOrganizationIdBillingChangeFrequencyPostError>> {
124 let p_organization_id = organization_id;
126 let p_change_plan_frequency_request = change_plan_frequency_request;
127
128 let uri_str = format!(
129 "{}/organizations/{organizationId}/billing/change-frequency",
130 configuration.base_path,
131 organizationId = crate::apis::urlencode(p_organization_id.to_string())
132 );
133 let mut req_builder = configuration
134 .client
135 .request(reqwest::Method::POST, &uri_str);
136
137 if let Some(ref user_agent) = configuration.user_agent {
138 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
139 }
140 if let Some(ref token) = configuration.oauth_access_token {
141 req_builder = req_builder.bearer_auth(token.to_owned());
142 };
143 req_builder = req_builder.json(&p_change_plan_frequency_request);
144
145 let req = req_builder.build()?;
146 let resp = configuration.client.execute(req).await?;
147
148 let status = resp.status();
149
150 if !status.is_client_error() && !status.is_server_error() {
151 Ok(())
152 } else {
153 let content = resp.text().await?;
154 let entity: Option<OrganizationsOrganizationIdBillingChangeFrequencyPostError> =
155 serde_json::from_str(&content).ok();
156 Err(Error::ResponseError(ResponseContent {
157 status,
158 content,
159 entity,
160 }))
161 }
162}
163
164pub async fn organizations_organization_id_billing_get(
165 configuration: &configuration::Configuration,
166 organization_id: uuid::Uuid,
167) -> Result<(), Error<OrganizationsOrganizationIdBillingGetError>> {
168 let p_organization_id = organization_id;
170
171 let uri_str = format!(
172 "{}/organizations/{organizationId}/billing",
173 configuration.base_path,
174 organizationId = crate::apis::urlencode(p_organization_id.to_string())
175 );
176 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
177
178 if let Some(ref user_agent) = configuration.user_agent {
179 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
180 }
181 if let Some(ref token) = configuration.oauth_access_token {
182 req_builder = req_builder.bearer_auth(token.to_owned());
183 };
184
185 let req = req_builder.build()?;
186 let resp = configuration.client.execute(req).await?;
187
188 let status = resp.status();
189
190 if !status.is_client_error() && !status.is_server_error() {
191 Ok(())
192 } else {
193 let content = resp.text().await?;
194 let entity: Option<OrganizationsOrganizationIdBillingGetError> =
195 serde_json::from_str(&content).ok();
196 Err(Error::ResponseError(ResponseContent {
197 status,
198 content,
199 entity,
200 }))
201 }
202}
203
204pub async fn organizations_organization_id_billing_history_get(
205 configuration: &configuration::Configuration,
206 organization_id: uuid::Uuid,
207) -> Result<(), Error<OrganizationsOrganizationIdBillingHistoryGetError>> {
208 let p_organization_id = organization_id;
210
211 let uri_str = format!(
212 "{}/organizations/{organizationId}/billing/history",
213 configuration.base_path,
214 organizationId = crate::apis::urlencode(p_organization_id.to_string())
215 );
216 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
217
218 if let Some(ref user_agent) = configuration.user_agent {
219 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
220 }
221 if let Some(ref token) = configuration.oauth_access_token {
222 req_builder = req_builder.bearer_auth(token.to_owned());
223 };
224
225 let req = req_builder.build()?;
226 let resp = configuration.client.execute(req).await?;
227
228 let status = resp.status();
229
230 if !status.is_client_error() && !status.is_server_error() {
231 Ok(())
232 } else {
233 let content = resp.text().await?;
234 let entity: Option<OrganizationsOrganizationIdBillingHistoryGetError> =
235 serde_json::from_str(&content).ok();
236 Err(Error::ResponseError(ResponseContent {
237 status,
238 content,
239 entity,
240 }))
241 }
242}
243
244pub async fn organizations_organization_id_billing_invoices_get(
245 configuration: &configuration::Configuration,
246 organization_id: uuid::Uuid,
247 status: Option<&str>,
248 start_after: Option<&str>,
249) -> Result<(), Error<OrganizationsOrganizationIdBillingInvoicesGetError>> {
250 let p_organization_id = organization_id;
252 let p_status = status;
253 let p_start_after = start_after;
254
255 let uri_str = format!(
256 "{}/organizations/{organizationId}/billing/invoices",
257 configuration.base_path,
258 organizationId = crate::apis::urlencode(p_organization_id.to_string())
259 );
260 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
261
262 if let Some(ref param_value) = p_status {
263 req_builder = req_builder.query(&[("status", ¶m_value.to_string())]);
264 }
265 if let Some(ref param_value) = p_start_after {
266 req_builder = req_builder.query(&[("startAfter", ¶m_value.to_string())]);
267 }
268 if let Some(ref user_agent) = configuration.user_agent {
269 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
270 }
271 if let Some(ref token) = configuration.oauth_access_token {
272 req_builder = req_builder.bearer_auth(token.to_owned());
273 };
274
275 let req = req_builder.build()?;
276 let resp = configuration.client.execute(req).await?;
277
278 let status = resp.status();
279
280 if !status.is_client_error() && !status.is_server_error() {
281 Ok(())
282 } else {
283 let content = resp.text().await?;
284 let entity: Option<OrganizationsOrganizationIdBillingInvoicesGetError> =
285 serde_json::from_str(&content).ok();
286 Err(Error::ResponseError(ResponseContent {
287 status,
288 content,
289 entity,
290 }))
291 }
292}
293
294pub async fn organizations_organization_id_billing_metadata_get(
295 configuration: &configuration::Configuration,
296 organization_id: uuid::Uuid,
297) -> Result<(), Error<OrganizationsOrganizationIdBillingMetadataGetError>> {
298 let p_organization_id = organization_id;
300
301 let uri_str = format!(
302 "{}/organizations/{organizationId}/billing/metadata",
303 configuration.base_path,
304 organizationId = crate::apis::urlencode(p_organization_id.to_string())
305 );
306 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
307
308 if let Some(ref user_agent) = configuration.user_agent {
309 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
310 }
311 if let Some(ref token) = configuration.oauth_access_token {
312 req_builder = req_builder.bearer_auth(token.to_owned());
313 };
314
315 let req = req_builder.build()?;
316 let resp = configuration.client.execute(req).await?;
317
318 let status = resp.status();
319
320 if !status.is_client_error() && !status.is_server_error() {
321 Ok(())
322 } else {
323 let content = resp.text().await?;
324 let entity: Option<OrganizationsOrganizationIdBillingMetadataGetError> =
325 serde_json::from_str(&content).ok();
326 Err(Error::ResponseError(ResponseContent {
327 status,
328 content,
329 entity,
330 }))
331 }
332}
333
334pub async fn organizations_organization_id_billing_payment_method_get(
335 configuration: &configuration::Configuration,
336 organization_id: uuid::Uuid,
337) -> Result<(), Error<OrganizationsOrganizationIdBillingPaymentMethodGetError>> {
338 let p_organization_id = organization_id;
340
341 let uri_str = format!(
342 "{}/organizations/{organizationId}/billing/payment-method",
343 configuration.base_path,
344 organizationId = crate::apis::urlencode(p_organization_id.to_string())
345 );
346 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
347
348 if let Some(ref user_agent) = configuration.user_agent {
349 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
350 }
351 if let Some(ref token) = configuration.oauth_access_token {
352 req_builder = req_builder.bearer_auth(token.to_owned());
353 };
354
355 let req = req_builder.build()?;
356 let resp = configuration.client.execute(req).await?;
357
358 let status = resp.status();
359
360 if !status.is_client_error() && !status.is_server_error() {
361 Ok(())
362 } else {
363 let content = resp.text().await?;
364 let entity: Option<OrganizationsOrganizationIdBillingPaymentMethodGetError> =
365 serde_json::from_str(&content).ok();
366 Err(Error::ResponseError(ResponseContent {
367 status,
368 content,
369 entity,
370 }))
371 }
372}
373
374pub async fn organizations_organization_id_billing_payment_method_put(
375 configuration: &configuration::Configuration,
376 organization_id: uuid::Uuid,
377 update_payment_method_request_body: Option<models::UpdatePaymentMethodRequestBody>,
378) -> Result<(), Error<OrganizationsOrganizationIdBillingPaymentMethodPutError>> {
379 let p_organization_id = organization_id;
381 let p_update_payment_method_request_body = update_payment_method_request_body;
382
383 let uri_str = format!(
384 "{}/organizations/{organizationId}/billing/payment-method",
385 configuration.base_path,
386 organizationId = crate::apis::urlencode(p_organization_id.to_string())
387 );
388 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
389
390 if let Some(ref user_agent) = configuration.user_agent {
391 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
392 }
393 if let Some(ref token) = configuration.oauth_access_token {
394 req_builder = req_builder.bearer_auth(token.to_owned());
395 };
396 req_builder = req_builder.json(&p_update_payment_method_request_body);
397
398 let req = req_builder.build()?;
399 let resp = configuration.client.execute(req).await?;
400
401 let status = resp.status();
402
403 if !status.is_client_error() && !status.is_server_error() {
404 Ok(())
405 } else {
406 let content = resp.text().await?;
407 let entity: Option<OrganizationsOrganizationIdBillingPaymentMethodPutError> =
408 serde_json::from_str(&content).ok();
409 Err(Error::ResponseError(ResponseContent {
410 status,
411 content,
412 entity,
413 }))
414 }
415}
416
417pub async fn organizations_organization_id_billing_payment_method_verify_bank_account_post(
418 configuration: &configuration::Configuration,
419 organization_id: uuid::Uuid,
420 verify_bank_account_request_body: Option<models::VerifyBankAccountRequestBody>,
421) -> Result<(), Error<OrganizationsOrganizationIdBillingPaymentMethodVerifyBankAccountPostError>> {
422 let p_organization_id = organization_id;
424 let p_verify_bank_account_request_body = verify_bank_account_request_body;
425
426 let uri_str = format!(
427 "{}/organizations/{organizationId}/billing/payment-method/verify-bank-account",
428 configuration.base_path,
429 organizationId = crate::apis::urlencode(p_organization_id.to_string())
430 );
431 let mut req_builder = configuration
432 .client
433 .request(reqwest::Method::POST, &uri_str);
434
435 if let Some(ref user_agent) = configuration.user_agent {
436 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
437 }
438 if let Some(ref token) = configuration.oauth_access_token {
439 req_builder = req_builder.bearer_auth(token.to_owned());
440 };
441 req_builder = req_builder.json(&p_verify_bank_account_request_body);
442
443 let req = req_builder.build()?;
444 let resp = configuration.client.execute(req).await?;
445
446 let status = resp.status();
447
448 if !status.is_client_error() && !status.is_server_error() {
449 Ok(())
450 } else {
451 let content = resp.text().await?;
452 let entity: Option<
453 OrganizationsOrganizationIdBillingPaymentMethodVerifyBankAccountPostError,
454 > = serde_json::from_str(&content).ok();
455 Err(Error::ResponseError(ResponseContent {
456 status,
457 content,
458 entity,
459 }))
460 }
461}
462
463pub async fn organizations_organization_id_billing_restart_subscription_post(
464 configuration: &configuration::Configuration,
465 organization_id: uuid::Uuid,
466 organization_create_request_model: Option<models::OrganizationCreateRequestModel>,
467) -> Result<(), Error<OrganizationsOrganizationIdBillingRestartSubscriptionPostError>> {
468 let p_organization_id = organization_id;
470 let p_organization_create_request_model = organization_create_request_model;
471
472 let uri_str = format!(
473 "{}/organizations/{organizationId}/billing/restart-subscription",
474 configuration.base_path,
475 organizationId = crate::apis::urlencode(p_organization_id.to_string())
476 );
477 let mut req_builder = configuration
478 .client
479 .request(reqwest::Method::POST, &uri_str);
480
481 if let Some(ref user_agent) = configuration.user_agent {
482 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
483 }
484 if let Some(ref token) = configuration.oauth_access_token {
485 req_builder = req_builder.bearer_auth(token.to_owned());
486 };
487 req_builder = req_builder.json(&p_organization_create_request_model);
488
489 let req = req_builder.build()?;
490 let resp = configuration.client.execute(req).await?;
491
492 let status = resp.status();
493
494 if !status.is_client_error() && !status.is_server_error() {
495 Ok(())
496 } else {
497 let content = resp.text().await?;
498 let entity: Option<OrganizationsOrganizationIdBillingRestartSubscriptionPostError> =
499 serde_json::from_str(&content).ok();
500 Err(Error::ResponseError(ResponseContent {
501 status,
502 content,
503 entity,
504 }))
505 }
506}
507
508pub async fn organizations_organization_id_billing_setup_business_unit_post(
509 configuration: &configuration::Configuration,
510 organization_id: uuid::Uuid,
511 setup_business_unit_request_body: Option<models::SetupBusinessUnitRequestBody>,
512) -> Result<(), Error<OrganizationsOrganizationIdBillingSetupBusinessUnitPostError>> {
513 let p_organization_id = organization_id;
515 let p_setup_business_unit_request_body = setup_business_unit_request_body;
516
517 let uri_str = format!(
518 "{}/organizations/{organizationId}/billing/setup-business-unit",
519 configuration.base_path,
520 organizationId = crate::apis::urlencode(p_organization_id.to_string())
521 );
522 let mut req_builder = configuration
523 .client
524 .request(reqwest::Method::POST, &uri_str);
525
526 if let Some(ref user_agent) = configuration.user_agent {
527 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
528 }
529 if let Some(ref token) = configuration.oauth_access_token {
530 req_builder = req_builder.bearer_auth(token.to_owned());
531 };
532 req_builder = req_builder.json(&p_setup_business_unit_request_body);
533
534 let req = req_builder.build()?;
535 let resp = configuration.client.execute(req).await?;
536
537 let status = resp.status();
538
539 if !status.is_client_error() && !status.is_server_error() {
540 Ok(())
541 } else {
542 let content = resp.text().await?;
543 let entity: Option<OrganizationsOrganizationIdBillingSetupBusinessUnitPostError> =
544 serde_json::from_str(&content).ok();
545 Err(Error::ResponseError(ResponseContent {
546 status,
547 content,
548 entity,
549 }))
550 }
551}
552
553pub async fn organizations_organization_id_billing_tax_information_get(
554 configuration: &configuration::Configuration,
555 organization_id: uuid::Uuid,
556) -> Result<(), Error<OrganizationsOrganizationIdBillingTaxInformationGetError>> {
557 let p_organization_id = organization_id;
559
560 let uri_str = format!(
561 "{}/organizations/{organizationId}/billing/tax-information",
562 configuration.base_path,
563 organizationId = crate::apis::urlencode(p_organization_id.to_string())
564 );
565 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
566
567 if let Some(ref user_agent) = configuration.user_agent {
568 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
569 }
570 if let Some(ref token) = configuration.oauth_access_token {
571 req_builder = req_builder.bearer_auth(token.to_owned());
572 };
573
574 let req = req_builder.build()?;
575 let resp = configuration.client.execute(req).await?;
576
577 let status = resp.status();
578
579 if !status.is_client_error() && !status.is_server_error() {
580 Ok(())
581 } else {
582 let content = resp.text().await?;
583 let entity: Option<OrganizationsOrganizationIdBillingTaxInformationGetError> =
584 serde_json::from_str(&content).ok();
585 Err(Error::ResponseError(ResponseContent {
586 status,
587 content,
588 entity,
589 }))
590 }
591}
592
593pub async fn organizations_organization_id_billing_tax_information_put(
594 configuration: &configuration::Configuration,
595 organization_id: uuid::Uuid,
596 tax_information_request_body: Option<models::TaxInformationRequestBody>,
597) -> Result<(), Error<OrganizationsOrganizationIdBillingTaxInformationPutError>> {
598 let p_organization_id = organization_id;
600 let p_tax_information_request_body = tax_information_request_body;
601
602 let uri_str = format!(
603 "{}/organizations/{organizationId}/billing/tax-information",
604 configuration.base_path,
605 organizationId = crate::apis::urlencode(p_organization_id.to_string())
606 );
607 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
608
609 if let Some(ref user_agent) = configuration.user_agent {
610 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
611 }
612 if let Some(ref token) = configuration.oauth_access_token {
613 req_builder = req_builder.bearer_auth(token.to_owned());
614 };
615 req_builder = req_builder.json(&p_tax_information_request_body);
616
617 let req = req_builder.build()?;
618 let resp = configuration.client.execute(req).await?;
619
620 let status = resp.status();
621
622 if !status.is_client_error() && !status.is_server_error() {
623 Ok(())
624 } else {
625 let content = resp.text().await?;
626 let entity: Option<OrganizationsOrganizationIdBillingTaxInformationPutError> =
627 serde_json::from_str(&content).ok();
628 Err(Error::ResponseError(ResponseContent {
629 status,
630 content,
631 entity,
632 }))
633 }
634}
635
636pub async fn organizations_organization_id_billing_transactions_get(
637 configuration: &configuration::Configuration,
638 organization_id: uuid::Uuid,
639 start_after: Option<String>,
640) -> Result<(), Error<OrganizationsOrganizationIdBillingTransactionsGetError>> {
641 let p_organization_id = organization_id;
643 let p_start_after = start_after;
644
645 let uri_str = format!(
646 "{}/organizations/{organizationId}/billing/transactions",
647 configuration.base_path,
648 organizationId = crate::apis::urlencode(p_organization_id.to_string())
649 );
650 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
651
652 if let Some(ref param_value) = p_start_after {
653 req_builder = req_builder.query(&[("startAfter", ¶m_value.to_string())]);
654 }
655 if let Some(ref user_agent) = configuration.user_agent {
656 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
657 }
658 if let Some(ref token) = configuration.oauth_access_token {
659 req_builder = req_builder.bearer_auth(token.to_owned());
660 };
661
662 let req = req_builder.build()?;
663 let resp = configuration.client.execute(req).await?;
664
665 let status = resp.status();
666
667 if !status.is_client_error() && !status.is_server_error() {
668 Ok(())
669 } else {
670 let content = resp.text().await?;
671 let entity: Option<OrganizationsOrganizationIdBillingTransactionsGetError> =
672 serde_json::from_str(&content).ok();
673 Err(Error::ResponseError(ResponseContent {
674 status,
675 content,
676 entity,
677 }))
678 }
679}
680
681pub async fn organizations_organization_id_billing_warnings_get(
682 configuration: &configuration::Configuration,
683 organization_id: uuid::Uuid,
684) -> Result<(), Error<OrganizationsOrganizationIdBillingWarningsGetError>> {
685 let p_organization_id = organization_id;
687
688 let uri_str = format!(
689 "{}/organizations/{organizationId}/billing/warnings",
690 configuration.base_path,
691 organizationId = crate::apis::urlencode(p_organization_id.to_string())
692 );
693 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
694
695 if let Some(ref user_agent) = configuration.user_agent {
696 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
697 }
698 if let Some(ref token) = configuration.oauth_access_token {
699 req_builder = req_builder.bearer_auth(token.to_owned());
700 };
701
702 let req = req_builder.build()?;
703 let resp = configuration.client.execute(req).await?;
704
705 let status = resp.status();
706
707 if !status.is_client_error() && !status.is_server_error() {
708 Ok(())
709 } else {
710 let content = resp.text().await?;
711 let entity: Option<OrganizationsOrganizationIdBillingWarningsGetError> =
712 serde_json::from_str(&content).ok();
713 Err(Error::ResponseError(ResponseContent {
714 status,
715 content,
716 entity,
717 }))
718 }
719}