bitwarden_api_identity/apis/
accounts_api.rs1use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum AccountsPreloginPostError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum AccountsRegisterFinishPostError {
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum AccountsRegisterPostError {
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum AccountsRegisterSendVerificationEmailPostError {
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum AccountsRegisterVerificationEmailClickedPostError {
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum AccountsTrialSendVerificationEmailPostError {
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum AccountsWebauthnAssertionOptionsGetError {
63 UnknownValue(serde_json::Value),
64}
65
66pub async fn accounts_prelogin_post(
67 configuration: &configuration::Configuration,
68 prelogin_request_model: Option<models::PreloginRequestModel>,
69) -> Result<models::PreloginResponseModel, Error<AccountsPreloginPostError>> {
70 let local_var_configuration = configuration;
71
72 let local_var_client = &local_var_configuration.client;
73
74 let local_var_uri_str = format!("{}/accounts/prelogin", local_var_configuration.base_path);
75 let mut local_var_req_builder =
76 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
77
78 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
79 local_var_req_builder =
80 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
81 }
82 local_var_req_builder = local_var_req_builder.json(&prelogin_request_model);
83
84 let local_var_req = local_var_req_builder.build()?;
85 let local_var_resp = local_var_client.execute(local_var_req).await?;
86
87 let local_var_status = local_var_resp.status();
88 let local_var_content = local_var_resp.text().await?;
89
90 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
91 serde_json::from_str(&local_var_content).map_err(Error::from)
92 } else {
93 let local_var_entity: Option<AccountsPreloginPostError> =
94 serde_json::from_str(&local_var_content).ok();
95 let local_var_error = ResponseContent {
96 status: local_var_status,
97 content: local_var_content,
98 entity: local_var_entity,
99 };
100 Err(Error::ResponseError(local_var_error))
101 }
102}
103
104pub async fn accounts_register_finish_post(
105 configuration: &configuration::Configuration,
106 register_finish_request_model: Option<models::RegisterFinishRequestModel>,
107) -> Result<models::RegisterResponseModel, Error<AccountsRegisterFinishPostError>> {
108 let local_var_configuration = configuration;
109
110 let local_var_client = &local_var_configuration.client;
111
112 let local_var_uri_str = format!(
113 "{}/accounts/register/finish",
114 local_var_configuration.base_path
115 );
116 let mut local_var_req_builder =
117 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
118
119 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
120 local_var_req_builder =
121 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
122 }
123 local_var_req_builder = local_var_req_builder.json(®ister_finish_request_model);
124
125 let local_var_req = local_var_req_builder.build()?;
126 let local_var_resp = local_var_client.execute(local_var_req).await?;
127
128 let local_var_status = local_var_resp.status();
129 let local_var_content = local_var_resp.text().await?;
130
131 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
132 serde_json::from_str(&local_var_content).map_err(Error::from)
133 } else {
134 let local_var_entity: Option<AccountsRegisterFinishPostError> =
135 serde_json::from_str(&local_var_content).ok();
136 let local_var_error = ResponseContent {
137 status: local_var_status,
138 content: local_var_content,
139 entity: local_var_entity,
140 };
141 Err(Error::ResponseError(local_var_error))
142 }
143}
144
145pub async fn accounts_register_post(
146 configuration: &configuration::Configuration,
147 register_request_model: Option<models::RegisterRequestModel>,
148) -> Result<models::RegisterResponseModel, Error<AccountsRegisterPostError>> {
149 let local_var_configuration = configuration;
150
151 let local_var_client = &local_var_configuration.client;
152
153 let local_var_uri_str = format!("{}/accounts/register", local_var_configuration.base_path);
154 let mut local_var_req_builder =
155 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
156
157 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
158 local_var_req_builder =
159 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
160 }
161 local_var_req_builder = local_var_req_builder.json(®ister_request_model);
162
163 let local_var_req = local_var_req_builder.build()?;
164 let local_var_resp = local_var_client.execute(local_var_req).await?;
165
166 let local_var_status = local_var_resp.status();
167 let local_var_content = local_var_resp.text().await?;
168
169 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
170 serde_json::from_str(&local_var_content).map_err(Error::from)
171 } else {
172 let local_var_entity: Option<AccountsRegisterPostError> =
173 serde_json::from_str(&local_var_content).ok();
174 let local_var_error = ResponseContent {
175 status: local_var_status,
176 content: local_var_content,
177 entity: local_var_entity,
178 };
179 Err(Error::ResponseError(local_var_error))
180 }
181}
182
183pub async fn accounts_register_send_verification_email_post(
184 configuration: &configuration::Configuration,
185 register_send_verification_email_request_model: Option<
186 models::RegisterSendVerificationEmailRequestModel,
187 >,
188) -> Result<(), Error<AccountsRegisterSendVerificationEmailPostError>> {
189 let local_var_configuration = configuration;
190
191 let local_var_client = &local_var_configuration.client;
192
193 let local_var_uri_str = format!(
194 "{}/accounts/register/send-verification-email",
195 local_var_configuration.base_path
196 );
197 let mut local_var_req_builder =
198 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
199
200 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
201 local_var_req_builder =
202 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
203 }
204 local_var_req_builder =
205 local_var_req_builder.json(®ister_send_verification_email_request_model);
206
207 let local_var_req = local_var_req_builder.build()?;
208 let local_var_resp = local_var_client.execute(local_var_req).await?;
209
210 let local_var_status = local_var_resp.status();
211 let local_var_content = local_var_resp.text().await?;
212
213 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
214 Ok(())
215 } else {
216 let local_var_entity: Option<AccountsRegisterSendVerificationEmailPostError> =
217 serde_json::from_str(&local_var_content).ok();
218 let local_var_error = ResponseContent {
219 status: local_var_status,
220 content: local_var_content,
221 entity: local_var_entity,
222 };
223 Err(Error::ResponseError(local_var_error))
224 }
225}
226
227pub async fn accounts_register_verification_email_clicked_post(
228 configuration: &configuration::Configuration,
229 register_verification_email_clicked_request_model: Option<
230 models::RegisterVerificationEmailClickedRequestModel,
231 >,
232) -> Result<(), Error<AccountsRegisterVerificationEmailClickedPostError>> {
233 let local_var_configuration = configuration;
234
235 let local_var_client = &local_var_configuration.client;
236
237 let local_var_uri_str = format!(
238 "{}/accounts/register/verification-email-clicked",
239 local_var_configuration.base_path
240 );
241 let mut local_var_req_builder =
242 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
243
244 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
245 local_var_req_builder =
246 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
247 }
248 local_var_req_builder =
249 local_var_req_builder.json(®ister_verification_email_clicked_request_model);
250
251 let local_var_req = local_var_req_builder.build()?;
252 let local_var_resp = local_var_client.execute(local_var_req).await?;
253
254 let local_var_status = local_var_resp.status();
255 let local_var_content = local_var_resp.text().await?;
256
257 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
258 Ok(())
259 } else {
260 let local_var_entity: Option<AccountsRegisterVerificationEmailClickedPostError> =
261 serde_json::from_str(&local_var_content).ok();
262 let local_var_error = ResponseContent {
263 status: local_var_status,
264 content: local_var_content,
265 entity: local_var_entity,
266 };
267 Err(Error::ResponseError(local_var_error))
268 }
269}
270
271pub async fn accounts_trial_send_verification_email_post(
272 configuration: &configuration::Configuration,
273 trial_send_verification_email_request_model: Option<
274 models::TrialSendVerificationEmailRequestModel,
275 >,
276) -> Result<(), Error<AccountsTrialSendVerificationEmailPostError>> {
277 let local_var_configuration = configuration;
278
279 let local_var_client = &local_var_configuration.client;
280
281 let local_var_uri_str = format!(
282 "{}/accounts/trial/send-verification-email",
283 local_var_configuration.base_path
284 );
285 let mut local_var_req_builder =
286 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
287
288 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
289 local_var_req_builder =
290 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
291 }
292 local_var_req_builder =
293 local_var_req_builder.json(&trial_send_verification_email_request_model);
294
295 let local_var_req = local_var_req_builder.build()?;
296 let local_var_resp = local_var_client.execute(local_var_req).await?;
297
298 let local_var_status = local_var_resp.status();
299 let local_var_content = local_var_resp.text().await?;
300
301 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
302 Ok(())
303 } else {
304 let local_var_entity: Option<AccountsTrialSendVerificationEmailPostError> =
305 serde_json::from_str(&local_var_content).ok();
306 let local_var_error = ResponseContent {
307 status: local_var_status,
308 content: local_var_content,
309 entity: local_var_entity,
310 };
311 Err(Error::ResponseError(local_var_error))
312 }
313}
314
315pub async fn accounts_webauthn_assertion_options_get(
316 configuration: &configuration::Configuration,
317) -> Result<
318 models::WebAuthnLoginAssertionOptionsResponseModel,
319 Error<AccountsWebauthnAssertionOptionsGetError>,
320> {
321 let local_var_configuration = configuration;
322
323 let local_var_client = &local_var_configuration.client;
324
325 let local_var_uri_str = format!(
326 "{}/accounts/webauthn/assertion-options",
327 local_var_configuration.base_path
328 );
329 let mut local_var_req_builder =
330 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
331
332 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
333 local_var_req_builder =
334 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
335 }
336
337 let local_var_req = local_var_req_builder.build()?;
338 let local_var_resp = local_var_client.execute(local_var_req).await?;
339
340 let local_var_status = local_var_resp.status();
341 let local_var_content = local_var_resp.text().await?;
342
343 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
344 serde_json::from_str(&local_var_content).map_err(Error::from)
345 } else {
346 let local_var_entity: Option<AccountsWebauthnAssertionOptionsGetError> =
347 serde_json::from_str(&local_var_content).ok();
348 let local_var_error = ResponseContent {
349 status: local_var_status,
350 content: local_var_content,
351 entity: local_var_entity,
352 };
353 Err(Error::ResponseError(local_var_error))
354 }
355}