bitwarden_api_api/apis/
provider_clients_api.rs1use 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::{AuthRequired, 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 ProviderClientsApi: Send + Sync {
29 async fn add_existing_organization<'a>(
31 &self,
32 provider_id: uuid::Uuid,
33 add_existing_organization_request_body: Option<models::AddExistingOrganizationRequestBody>,
34 ) -> Result<(), Error<AddExistingOrganizationError>>;
35
36 async fn create<'a>(
38 &self,
39 provider_id: uuid::Uuid,
40 create_client_organization_request_body: Option<
41 models::CreateClientOrganizationRequestBody,
42 >,
43 ) -> Result<(), Error<CreateError>>;
44
45 async fn get_addable_organizations<'a>(
47 &self,
48 provider_id: uuid::Uuid,
49 ) -> Result<(), Error<GetAddableOrganizationsError>>;
50
51 async fn update<'a>(
53 &self,
54 provider_id: uuid::Uuid,
55 provider_organization_id: uuid::Uuid,
56 update_client_organization_request_body: Option<
57 models::UpdateClientOrganizationRequestBody,
58 >,
59 ) -> Result<(), Error<UpdateError>>;
60}
61
62pub struct ProviderClientsApiClient {
63 configuration: Arc<configuration::Configuration>,
64}
65
66impl ProviderClientsApiClient {
67 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
68 Self { configuration }
69 }
70}
71
72#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
73#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
74impl ProviderClientsApi for ProviderClientsApiClient {
75 async fn add_existing_organization<'a>(
76 &self,
77 provider_id: uuid::Uuid,
78 add_existing_organization_request_body: Option<models::AddExistingOrganizationRequestBody>,
79 ) -> Result<(), Error<AddExistingOrganizationError>> {
80 let local_var_configuration = &self.configuration;
81
82 let local_var_client = &local_var_configuration.client;
83
84 let local_var_uri_str = format!(
85 "{}/providers/{providerId}/clients/existing",
86 local_var_configuration.base_path,
87 providerId = provider_id
88 );
89 let mut local_var_req_builder =
90 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
91
92 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
93 local_var_req_builder = local_var_req_builder.json(&add_existing_organization_request_body);
94
95 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
96 }
97
98 async fn create<'a>(
99 &self,
100 provider_id: uuid::Uuid,
101 create_client_organization_request_body: Option<
102 models::CreateClientOrganizationRequestBody,
103 >,
104 ) -> Result<(), Error<CreateError>> {
105 let local_var_configuration = &self.configuration;
106
107 let local_var_client = &local_var_configuration.client;
108
109 let local_var_uri_str = format!(
110 "{}/providers/{providerId}/clients",
111 local_var_configuration.base_path,
112 providerId = provider_id
113 );
114 let mut local_var_req_builder =
115 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
116
117 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
118 local_var_req_builder =
119 local_var_req_builder.json(&create_client_organization_request_body);
120
121 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
122 }
123
124 async fn get_addable_organizations<'a>(
125 &self,
126 provider_id: uuid::Uuid,
127 ) -> Result<(), Error<GetAddableOrganizationsError>> {
128 let local_var_configuration = &self.configuration;
129
130 let local_var_client = &local_var_configuration.client;
131
132 let local_var_uri_str = format!(
133 "{}/providers/{providerId}/clients/addable",
134 local_var_configuration.base_path,
135 providerId = provider_id
136 );
137 let mut local_var_req_builder =
138 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
139
140 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
141
142 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
143 }
144
145 async fn update<'a>(
146 &self,
147 provider_id: uuid::Uuid,
148 provider_organization_id: uuid::Uuid,
149 update_client_organization_request_body: Option<
150 models::UpdateClientOrganizationRequestBody,
151 >,
152 ) -> Result<(), Error<UpdateError>> {
153 let local_var_configuration = &self.configuration;
154
155 let local_var_client = &local_var_configuration.client;
156
157 let local_var_uri_str = format!(
158 "{}/providers/{providerId}/clients/{providerOrganizationId}",
159 local_var_configuration.base_path,
160 providerId = provider_id,
161 providerOrganizationId = provider_organization_id
162 );
163 let mut local_var_req_builder =
164 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
165
166 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
167 local_var_req_builder =
168 local_var_req_builder.json(&update_client_organization_request_body);
169
170 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
171 }
172}
173
174#[derive(Debug, Clone, Serialize, Deserialize)]
176#[serde(untagged)]
177pub enum AddExistingOrganizationError {
178 UnknownValue(serde_json::Value),
179}
180#[derive(Debug, Clone, Serialize, Deserialize)]
182#[serde(untagged)]
183pub enum CreateError {
184 UnknownValue(serde_json::Value),
185}
186#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum GetAddableOrganizationsError {
190 UnknownValue(serde_json::Value),
191}
192#[derive(Debug, Clone, Serialize, Deserialize)]
194#[serde(untagged)]
195pub enum UpdateError {
196 UnknownValue(serde_json::Value),
197}