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