Skip to main content

bitwarden_api_api/apis/
accounts_key_management_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::{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 AccountsKeyManagementApi: Send + Sync {
29    /// GET /accounts/key-connector/confirmation-details/{orgSsoIdentifier}
30    async fn get_key_connector_confirmation_details<'a>(
31        &self,
32        org_sso_identifier: &'a str,
33    ) -> Result<models::KeyConnectorConfirmationDetailsResponseModel, Error>;
34
35    /// GET /accounts/key-management/key-rotation-data
36    async fn get_key_rotation_data(&self) -> Result<models::KeyRotationDataResponseModel, Error>;
37
38    /// POST /accounts/key-management/rotate-user-account-keys
39    async fn password_change_and_rotate_user_account_keys<'a>(
40        &self,
41        rotate_user_account_keys_and_data_request_model: Option<
42            models::RotateUserAccountKeysAndDataRequestModel,
43        >,
44    ) -> Result<(), Error>;
45
46    /// POST /accounts/convert-to-key-connector
47    async fn post_convert_to_key_connector(&self) -> Result<(), Error>;
48
49    /// POST /accounts/key-connector/enroll
50    async fn post_enroll_to_key_connector<'a>(
51        &self,
52        key_connector_enrollment_request_model: Option<models::KeyConnectorEnrollmentRequestModel>,
53    ) -> Result<(), Error>;
54
55    /// POST /accounts/set-key-connector-key
56    async fn post_set_key_connector_key<'a>(
57        &self,
58        set_key_connector_key_request_model: Option<models::SetKeyConnectorKeyRequestModel>,
59    ) -> Result<(), Error>;
60
61    /// POST /accounts/key-management/user-key-id
62    /// This is meant for backfilling the user-key id for existing users for whom the key id is not
63    /// yet recorded.
64    async fn post_user_key_id<'a>(
65        &self,
66        set_user_key_id_request_model: Option<models::SetUserKeyIdRequestModel>,
67    ) -> Result<(), Error>;
68
69    /// POST /accounts/key-management/regenerate-keys
70    async fn regenerate_keys<'a>(
71        &self,
72        key_regeneration_request_model: Option<models::KeyRegenerationRequestModel>,
73    ) -> Result<(), Error>;
74
75    /// POST /accounts/key-management/rotate-user-keys
76    async fn rotate_user_keys<'a>(
77        &self,
78        rotate_user_keys_request_model: Option<models::RotateUserKeysRequestModel>,
79    ) -> Result<(), Error>;
80}
81
82pub struct AccountsKeyManagementApiClient {
83    configuration: Arc<configuration::Configuration>,
84}
85
86impl AccountsKeyManagementApiClient {
87    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
88        Self { configuration }
89    }
90}
91
92#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
93#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
94impl AccountsKeyManagementApi for AccountsKeyManagementApiClient {
95    async fn get_key_connector_confirmation_details<'a>(
96        &self,
97        org_sso_identifier: &'a str,
98    ) -> Result<models::KeyConnectorConfirmationDetailsResponseModel, Error> {
99        let local_var_configuration = &self.configuration;
100
101        let local_var_client = &local_var_configuration.client;
102
103        let local_var_uri_str = format!(
104            "{}/accounts/key-connector/confirmation-details/{orgSsoIdentifier}",
105            local_var_configuration.base_path,
106            orgSsoIdentifier = crate::apis::urlencode(org_sso_identifier)
107        );
108        let mut local_var_req_builder =
109            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
110
111        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
112
113        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
114    }
115
116    async fn get_key_rotation_data(&self) -> Result<models::KeyRotationDataResponseModel, Error> {
117        let local_var_configuration = &self.configuration;
118
119        let local_var_client = &local_var_configuration.client;
120
121        let local_var_uri_str = format!(
122            "{}/accounts/key-management/key-rotation-data",
123            local_var_configuration.base_path
124        );
125        let mut local_var_req_builder =
126            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
127
128        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
129
130        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
131    }
132
133    async fn password_change_and_rotate_user_account_keys<'a>(
134        &self,
135        rotate_user_account_keys_and_data_request_model: Option<
136            models::RotateUserAccountKeysAndDataRequestModel,
137        >,
138    ) -> Result<(), Error> {
139        let local_var_configuration = &self.configuration;
140
141        let local_var_client = &local_var_configuration.client;
142
143        let local_var_uri_str = format!(
144            "{}/accounts/key-management/rotate-user-account-keys",
145            local_var_configuration.base_path
146        );
147        let mut local_var_req_builder =
148            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
149
150        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
151        local_var_req_builder =
152            local_var_req_builder.json(&rotate_user_account_keys_and_data_request_model);
153
154        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
155    }
156
157    async fn post_convert_to_key_connector(&self) -> Result<(), Error> {
158        let local_var_configuration = &self.configuration;
159
160        let local_var_client = &local_var_configuration.client;
161
162        let local_var_uri_str = format!(
163            "{}/accounts/convert-to-key-connector",
164            local_var_configuration.base_path
165        );
166        let mut local_var_req_builder =
167            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
168
169        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
170
171        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
172    }
173
174    async fn post_enroll_to_key_connector<'a>(
175        &self,
176        key_connector_enrollment_request_model: Option<models::KeyConnectorEnrollmentRequestModel>,
177    ) -> Result<(), Error> {
178        let local_var_configuration = &self.configuration;
179
180        let local_var_client = &local_var_configuration.client;
181
182        let local_var_uri_str = format!(
183            "{}/accounts/key-connector/enroll",
184            local_var_configuration.base_path
185        );
186        let mut local_var_req_builder =
187            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
188
189        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
190        local_var_req_builder = local_var_req_builder.json(&key_connector_enrollment_request_model);
191
192        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
193    }
194
195    async fn post_set_key_connector_key<'a>(
196        &self,
197        set_key_connector_key_request_model: Option<models::SetKeyConnectorKeyRequestModel>,
198    ) -> Result<(), Error> {
199        let local_var_configuration = &self.configuration;
200
201        let local_var_client = &local_var_configuration.client;
202
203        let local_var_uri_str = format!(
204            "{}/accounts/set-key-connector-key",
205            local_var_configuration.base_path
206        );
207        let mut local_var_req_builder =
208            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
209
210        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
211        local_var_req_builder = local_var_req_builder.json(&set_key_connector_key_request_model);
212
213        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
214    }
215
216    /// This is meant for backfilling the user-key id for existing users for whom the key id is not
217    /// yet recorded.
218    async fn post_user_key_id<'a>(
219        &self,
220        set_user_key_id_request_model: Option<models::SetUserKeyIdRequestModel>,
221    ) -> Result<(), Error> {
222        let local_var_configuration = &self.configuration;
223
224        let local_var_client = &local_var_configuration.client;
225
226        let local_var_uri_str = format!(
227            "{}/accounts/key-management/user-key-id",
228            local_var_configuration.base_path
229        );
230        let mut local_var_req_builder =
231            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
232
233        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
234        local_var_req_builder = local_var_req_builder.json(&set_user_key_id_request_model);
235
236        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
237    }
238
239    async fn regenerate_keys<'a>(
240        &self,
241        key_regeneration_request_model: Option<models::KeyRegenerationRequestModel>,
242    ) -> Result<(), Error> {
243        let local_var_configuration = &self.configuration;
244
245        let local_var_client = &local_var_configuration.client;
246
247        let local_var_uri_str = format!(
248            "{}/accounts/key-management/regenerate-keys",
249            local_var_configuration.base_path
250        );
251        let mut local_var_req_builder =
252            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
253
254        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
255        local_var_req_builder = local_var_req_builder.json(&key_regeneration_request_model);
256
257        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
258    }
259
260    async fn rotate_user_keys<'a>(
261        &self,
262        rotate_user_keys_request_model: Option<models::RotateUserKeysRequestModel>,
263    ) -> Result<(), Error> {
264        let local_var_configuration = &self.configuration;
265
266        let local_var_client = &local_var_configuration.client;
267
268        let local_var_uri_str = format!(
269            "{}/accounts/key-management/rotate-user-keys",
270            local_var_configuration.base_path
271        );
272        let mut local_var_req_builder =
273            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
274
275        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
276        local_var_req_builder = local_var_req_builder.json(&rotate_user_keys_request_model);
277
278        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
279    }
280}