1use 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 ProvidersIdDeleteError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum ProvidersIdDeletePostError {
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum ProvidersIdDeleteRecoverTokenPostError {
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum ProvidersIdGetError {
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum ProvidersIdPostError {
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum ProvidersIdPutError {
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum ProvidersIdSetupPostError {
63 UnknownValue(serde_json::Value),
64}
65
66pub async fn providers_id_delete(
67 configuration: &configuration::Configuration,
68 id: uuid::Uuid,
69) -> Result<(), Error<ProvidersIdDeleteError>> {
70 let local_var_configuration = configuration;
71
72 let local_var_client = &local_var_configuration.client;
73
74 let local_var_uri_str = format!(
75 "{}/providers/{id}",
76 local_var_configuration.base_path,
77 id = crate::apis::urlencode(id.to_string())
78 );
79 let mut local_var_req_builder =
80 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
81
82 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
83 local_var_req_builder =
84 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
85 }
86 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
87 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
88 };
89
90 let local_var_req = local_var_req_builder.build()?;
91 let local_var_resp = local_var_client.execute(local_var_req).await?;
92
93 let local_var_status = local_var_resp.status();
94 let local_var_content = local_var_resp.text().await?;
95
96 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
97 Ok(())
98 } else {
99 let local_var_entity: Option<ProvidersIdDeleteError> =
100 serde_json::from_str(&local_var_content).ok();
101 let local_var_error = ResponseContent {
102 status: local_var_status,
103 content: local_var_content,
104 entity: local_var_entity,
105 };
106 Err(Error::ResponseError(local_var_error))
107 }
108}
109
110pub async fn providers_id_delete_post(
111 configuration: &configuration::Configuration,
112 id: uuid::Uuid,
113) -> Result<(), Error<ProvidersIdDeletePostError>> {
114 let local_var_configuration = configuration;
115
116 let local_var_client = &local_var_configuration.client;
117
118 let local_var_uri_str = format!(
119 "{}/providers/{id}/delete",
120 local_var_configuration.base_path,
121 id = crate::apis::urlencode(id.to_string())
122 );
123 let mut local_var_req_builder =
124 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
125
126 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
127 local_var_req_builder =
128 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
129 }
130 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
131 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
132 };
133
134 let local_var_req = local_var_req_builder.build()?;
135 let local_var_resp = local_var_client.execute(local_var_req).await?;
136
137 let local_var_status = local_var_resp.status();
138 let local_var_content = local_var_resp.text().await?;
139
140 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
141 Ok(())
142 } else {
143 let local_var_entity: Option<ProvidersIdDeletePostError> =
144 serde_json::from_str(&local_var_content).ok();
145 let local_var_error = ResponseContent {
146 status: local_var_status,
147 content: local_var_content,
148 entity: local_var_entity,
149 };
150 Err(Error::ResponseError(local_var_error))
151 }
152}
153
154pub async fn providers_id_delete_recover_token_post(
155 configuration: &configuration::Configuration,
156 id: uuid::Uuid,
157 provider_verify_delete_recover_request_model: Option<
158 models::ProviderVerifyDeleteRecoverRequestModel,
159 >,
160) -> Result<(), Error<ProvidersIdDeleteRecoverTokenPostError>> {
161 let local_var_configuration = configuration;
162
163 let local_var_client = &local_var_configuration.client;
164
165 let local_var_uri_str = format!(
166 "{}/providers/{id}/delete-recover-token",
167 local_var_configuration.base_path,
168 id = crate::apis::urlencode(id.to_string())
169 );
170 let mut local_var_req_builder =
171 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
172
173 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
174 local_var_req_builder =
175 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
176 }
177 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
178 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
179 };
180 local_var_req_builder =
181 local_var_req_builder.json(&provider_verify_delete_recover_request_model);
182
183 let local_var_req = local_var_req_builder.build()?;
184 let local_var_resp = local_var_client.execute(local_var_req).await?;
185
186 let local_var_status = local_var_resp.status();
187 let local_var_content = local_var_resp.text().await?;
188
189 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
190 Ok(())
191 } else {
192 let local_var_entity: Option<ProvidersIdDeleteRecoverTokenPostError> =
193 serde_json::from_str(&local_var_content).ok();
194 let local_var_error = ResponseContent {
195 status: local_var_status,
196 content: local_var_content,
197 entity: local_var_entity,
198 };
199 Err(Error::ResponseError(local_var_error))
200 }
201}
202
203pub async fn providers_id_get(
204 configuration: &configuration::Configuration,
205 id: uuid::Uuid,
206) -> Result<models::ProviderResponseModel, Error<ProvidersIdGetError>> {
207 let local_var_configuration = configuration;
208
209 let local_var_client = &local_var_configuration.client;
210
211 let local_var_uri_str = format!(
212 "{}/providers/{id}",
213 local_var_configuration.base_path,
214 id = crate::apis::urlencode(id.to_string())
215 );
216 let mut local_var_req_builder =
217 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
218
219 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
220 local_var_req_builder =
221 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
222 }
223 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
224 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
225 };
226
227 let local_var_req = local_var_req_builder.build()?;
228 let local_var_resp = local_var_client.execute(local_var_req).await?;
229
230 let local_var_status = local_var_resp.status();
231 let local_var_content = local_var_resp.text().await?;
232
233 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
234 serde_json::from_str(&local_var_content).map_err(Error::from)
235 } else {
236 let local_var_entity: Option<ProvidersIdGetError> =
237 serde_json::from_str(&local_var_content).ok();
238 let local_var_error = ResponseContent {
239 status: local_var_status,
240 content: local_var_content,
241 entity: local_var_entity,
242 };
243 Err(Error::ResponseError(local_var_error))
244 }
245}
246
247pub async fn providers_id_post(
248 configuration: &configuration::Configuration,
249 id: uuid::Uuid,
250 provider_update_request_model: Option<models::ProviderUpdateRequestModel>,
251) -> Result<models::ProviderResponseModel, Error<ProvidersIdPostError>> {
252 let local_var_configuration = configuration;
253
254 let local_var_client = &local_var_configuration.client;
255
256 let local_var_uri_str = format!(
257 "{}/providers/{id}",
258 local_var_configuration.base_path,
259 id = crate::apis::urlencode(id.to_string())
260 );
261 let mut local_var_req_builder =
262 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
263
264 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
265 local_var_req_builder =
266 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
267 }
268 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
269 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
270 };
271 local_var_req_builder = local_var_req_builder.json(&provider_update_request_model);
272
273 let local_var_req = local_var_req_builder.build()?;
274 let local_var_resp = local_var_client.execute(local_var_req).await?;
275
276 let local_var_status = local_var_resp.status();
277 let local_var_content = local_var_resp.text().await?;
278
279 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
280 serde_json::from_str(&local_var_content).map_err(Error::from)
281 } else {
282 let local_var_entity: Option<ProvidersIdPostError> =
283 serde_json::from_str(&local_var_content).ok();
284 let local_var_error = ResponseContent {
285 status: local_var_status,
286 content: local_var_content,
287 entity: local_var_entity,
288 };
289 Err(Error::ResponseError(local_var_error))
290 }
291}
292
293pub async fn providers_id_put(
294 configuration: &configuration::Configuration,
295 id: uuid::Uuid,
296 provider_update_request_model: Option<models::ProviderUpdateRequestModel>,
297) -> Result<models::ProviderResponseModel, Error<ProvidersIdPutError>> {
298 let local_var_configuration = configuration;
299
300 let local_var_client = &local_var_configuration.client;
301
302 let local_var_uri_str = format!(
303 "{}/providers/{id}",
304 local_var_configuration.base_path,
305 id = crate::apis::urlencode(id.to_string())
306 );
307 let mut local_var_req_builder =
308 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
309
310 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
311 local_var_req_builder =
312 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
313 }
314 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
315 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
316 };
317 local_var_req_builder = local_var_req_builder.json(&provider_update_request_model);
318
319 let local_var_req = local_var_req_builder.build()?;
320 let local_var_resp = local_var_client.execute(local_var_req).await?;
321
322 let local_var_status = local_var_resp.status();
323 let local_var_content = local_var_resp.text().await?;
324
325 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
326 serde_json::from_str(&local_var_content).map_err(Error::from)
327 } else {
328 let local_var_entity: Option<ProvidersIdPutError> =
329 serde_json::from_str(&local_var_content).ok();
330 let local_var_error = ResponseContent {
331 status: local_var_status,
332 content: local_var_content,
333 entity: local_var_entity,
334 };
335 Err(Error::ResponseError(local_var_error))
336 }
337}
338
339pub async fn providers_id_setup_post(
340 configuration: &configuration::Configuration,
341 id: uuid::Uuid,
342 provider_setup_request_model: Option<models::ProviderSetupRequestModel>,
343) -> Result<models::ProviderResponseModel, Error<ProvidersIdSetupPostError>> {
344 let local_var_configuration = configuration;
345
346 let local_var_client = &local_var_configuration.client;
347
348 let local_var_uri_str = format!(
349 "{}/providers/{id}/setup",
350 local_var_configuration.base_path,
351 id = crate::apis::urlencode(id.to_string())
352 );
353 let mut local_var_req_builder =
354 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
355
356 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
357 local_var_req_builder =
358 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
359 }
360 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
361 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
362 };
363 local_var_req_builder = local_var_req_builder.json(&provider_setup_request_model);
364
365 let local_var_req = local_var_req_builder.build()?;
366 let local_var_resp = local_var_client.execute(local_var_req).await?;
367
368 let local_var_status = local_var_resp.status();
369 let local_var_content = local_var_resp.text().await?;
370
371 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
372 serde_json::from_str(&local_var_content).map_err(Error::from)
373 } else {
374 let local_var_entity: Option<ProvidersIdSetupPostError> =
375 serde_json::from_str(&local_var_content).ok();
376 let local_var_error = ResponseContent {
377 status: local_var_status,
378 content: local_var_content,
379 entity: local_var_entity,
380 };
381 Err(Error::ResponseError(local_var_error))
382 }
383}