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 reqwest;
12use serde::{de::Error as _, Deserialize, Serialize};
13
14use super::{configuration, ContentType, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method
18/// [`organizations_organization_id_billing_change_frequency_post`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum OrganizationsOrganizationIdBillingChangeFrequencyPostError {
22    UnknownValue(serde_json::Value),
23}
24
25/// struct for typed errors of method [`organizations_organization_id_billing_get`]
26#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum OrganizationsOrganizationIdBillingGetError {
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`organizations_organization_id_billing_history_get`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum OrganizationsOrganizationIdBillingHistoryGetError {
36    UnknownValue(serde_json::Value),
37}
38
39/// struct for typed errors of method [`organizations_organization_id_billing_invoices_get`]
40#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum OrganizationsOrganizationIdBillingInvoicesGetError {
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`organizations_organization_id_billing_metadata_get`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum OrganizationsOrganizationIdBillingMetadataGetError {
50    UnknownValue(serde_json::Value),
51}
52
53/// struct for typed errors of method [`organizations_organization_id_billing_payment_method_get`]
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum OrganizationsOrganizationIdBillingPaymentMethodGetError {
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`organizations_organization_id_billing_payment_method_put`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum OrganizationsOrganizationIdBillingPaymentMethodPutError {
64    UnknownValue(serde_json::Value),
65}
66
67/// struct for typed errors of method
68/// [`organizations_organization_id_billing_payment_method_verify_bank_account_post`]
69#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum OrganizationsOrganizationIdBillingPaymentMethodVerifyBankAccountPostError {
72    UnknownValue(serde_json::Value),
73}
74
75/// struct for typed errors of method
76/// [`organizations_organization_id_billing_restart_subscription_post`]
77#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum OrganizationsOrganizationIdBillingRestartSubscriptionPostError {
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed errors of method
84/// [`organizations_organization_id_billing_setup_business_unit_post`]
85#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum OrganizationsOrganizationIdBillingSetupBusinessUnitPostError {
88    UnknownValue(serde_json::Value),
89}
90
91/// struct for typed errors of method [`organizations_organization_id_billing_tax_information_get`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum OrganizationsOrganizationIdBillingTaxInformationGetError {
95    UnknownValue(serde_json::Value),
96}
97
98/// struct for typed errors of method [`organizations_organization_id_billing_tax_information_put`]
99#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum OrganizationsOrganizationIdBillingTaxInformationPutError {
102    UnknownValue(serde_json::Value),
103}
104
105/// struct for typed errors of method [`organizations_organization_id_billing_transactions_get`]
106#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum OrganizationsOrganizationIdBillingTransactionsGetError {
109    UnknownValue(serde_json::Value),
110}
111
112/// struct for typed errors of method [`organizations_organization_id_billing_warnings_get`]
113#[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    // add a prefix to parameters to efficiently prevent name collisions
125    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    // add a prefix to parameters to efficiently prevent name collisions
169    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    // add a prefix to parameters to efficiently prevent name collisions
209    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    // add a prefix to parameters to efficiently prevent name collisions
251    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", &param_value.to_string())]);
264    }
265    if let Some(ref param_value) = p_start_after {
266        req_builder = req_builder.query(&[("startAfter", &param_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    // add a prefix to parameters to efficiently prevent name collisions
299    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    // add a prefix to parameters to efficiently prevent name collisions
339    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    // add a prefix to parameters to efficiently prevent name collisions
380    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    // add a prefix to parameters to efficiently prevent name collisions
423    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    // add a prefix to parameters to efficiently prevent name collisions
469    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    // add a prefix to parameters to efficiently prevent name collisions
514    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    // add a prefix to parameters to efficiently prevent name collisions
558    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    // add a prefix to parameters to efficiently prevent name collisions
599    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    // add a prefix to parameters to efficiently prevent name collisions
642    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", &param_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    // add a prefix to parameters to efficiently prevent name collisions
686    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}