bitwarden_api_api/apis/
organization_billing_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use 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    /// POST /organizations/{organizationId}/billing/change-frequency
30    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    /// GET /organizations/{organizationId}/billing
37    async fn get_billing<'a>(
38        &self,
39        organization_id: uuid::Uuid,
40    ) -> Result<(), Error<GetBillingError>>;
41
42    /// GET /organizations/{organizationId}/billing/history
43    async fn get_history<'a>(
44        &self,
45        organization_id: uuid::Uuid,
46    ) -> Result<(), Error<GetHistoryError>>;
47
48    /// GET /organizations/{organizationId}/billing/invoices
49    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    /// GET /organizations/{organizationId}/billing/metadata
57    async fn get_metadata<'a>(
58        &self,
59        organization_id: uuid::Uuid,
60    ) -> Result<(), Error<GetMetadataError>>;
61
62    /// GET /organizations/{organizationId}/billing/payment-method
63    async fn get_payment_method<'a>(
64        &self,
65        organization_id: uuid::Uuid,
66    ) -> Result<(), Error<GetPaymentMethodError>>;
67
68    /// GET /organizations/{organizationId}/billing/tax-information
69    async fn get_tax_information<'a>(
70        &self,
71        organization_id: uuid::Uuid,
72    ) -> Result<(), Error<GetTaxInformationError>>;
73
74    /// GET /organizations/{organizationId}/billing/transactions
75    async fn get_transactions<'a>(
76        &self,
77        organization_id: uuid::Uuid,
78        start_after: Option<String>,
79    ) -> Result<(), Error<GetTransactionsError>>;
80
81    /// POST /organizations/{organizationId}/billing/restart-subscription
82    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    /// POST /organizations/{organizationId}/billing/setup-business-unit
89    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    /// PUT /organizations/{organizationId}/billing/payment-method
96    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    /// PUT /organizations/{organizationId}/billing/tax-information
103    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    /// POST /organizations/{organizationId}/billing/payment-method/verify-bank-account
110    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", &param_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", &param_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", &param_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/// struct for typed errors of method [`OrganizationBillingApi::change_plan_subscription_frequency`]
731#[derive(Debug, Clone, Serialize, Deserialize)]
732#[serde(untagged)]
733pub enum ChangePlanSubscriptionFrequencyError {
734    UnknownValue(serde_json::Value),
735}
736/// struct for typed errors of method [`OrganizationBillingApi::get_billing`]
737#[derive(Debug, Clone, Serialize, Deserialize)]
738#[serde(untagged)]
739pub enum GetBillingError {
740    UnknownValue(serde_json::Value),
741}
742/// struct for typed errors of method [`OrganizationBillingApi::get_history`]
743#[derive(Debug, Clone, Serialize, Deserialize)]
744#[serde(untagged)]
745pub enum GetHistoryError {
746    UnknownValue(serde_json::Value),
747}
748/// struct for typed errors of method [`OrganizationBillingApi::get_invoices`]
749#[derive(Debug, Clone, Serialize, Deserialize)]
750#[serde(untagged)]
751pub enum GetInvoicesError {
752    UnknownValue(serde_json::Value),
753}
754/// struct for typed errors of method [`OrganizationBillingApi::get_metadata`]
755#[derive(Debug, Clone, Serialize, Deserialize)]
756#[serde(untagged)]
757pub enum GetMetadataError {
758    UnknownValue(serde_json::Value),
759}
760/// struct for typed errors of method [`OrganizationBillingApi::get_payment_method`]
761#[derive(Debug, Clone, Serialize, Deserialize)]
762#[serde(untagged)]
763pub enum GetPaymentMethodError {
764    UnknownValue(serde_json::Value),
765}
766/// struct for typed errors of method [`OrganizationBillingApi::get_tax_information`]
767#[derive(Debug, Clone, Serialize, Deserialize)]
768#[serde(untagged)]
769pub enum GetTaxInformationError {
770    UnknownValue(serde_json::Value),
771}
772/// struct for typed errors of method [`OrganizationBillingApi::get_transactions`]
773#[derive(Debug, Clone, Serialize, Deserialize)]
774#[serde(untagged)]
775pub enum GetTransactionsError {
776    UnknownValue(serde_json::Value),
777}
778/// struct for typed errors of method [`OrganizationBillingApi::restart_subscription`]
779#[derive(Debug, Clone, Serialize, Deserialize)]
780#[serde(untagged)]
781pub enum RestartSubscriptionError {
782    UnknownValue(serde_json::Value),
783}
784/// struct for typed errors of method [`OrganizationBillingApi::setup_business_unit`]
785#[derive(Debug, Clone, Serialize, Deserialize)]
786#[serde(untagged)]
787pub enum SetupBusinessUnitError {
788    UnknownValue(serde_json::Value),
789}
790/// struct for typed errors of method [`OrganizationBillingApi::update_payment_method`]
791#[derive(Debug, Clone, Serialize, Deserialize)]
792#[serde(untagged)]
793pub enum UpdatePaymentMethodError {
794    UnknownValue(serde_json::Value),
795}
796/// struct for typed errors of method [`OrganizationBillingApi::update_tax_information`]
797#[derive(Debug, Clone, Serialize, Deserialize)]
798#[serde(untagged)]
799pub enum UpdateTaxInformationError {
800    UnknownValue(serde_json::Value),
801}
802/// struct for typed errors of method [`OrganizationBillingApi::verify_bank_account`]
803#[derive(Debug, Clone, Serialize, Deserialize)]
804#[serde(untagged)]
805pub enum VerifyBankAccountError {
806    UnknownValue(serde_json::Value),
807}