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