1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ConnectCallbackError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum ConnectClientCredentialsError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum ConnectSlackCallbackError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum ConnectSlackCallbackInstanceError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ConnectSlackInitiateError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum ConnectSlackInstanceError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum CreateAccountError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum DisconnectAccountError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum DisconnectSlackError {
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum DisconnectTeamsError {
85 UnknownValue(serde_json::Value),
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum GetOAuthConnectError {
92 UnknownValue(serde_json::Value),
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum ListOAuthConnectsError {
99 UnknownValue(serde_json::Value),
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum ListOAuthLoginsError {
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum RefreshTokenError {
113 UnknownValue(serde_json::Value),
114}
115
116
117pub async fn connect_callback(configuration: &configuration::Configuration, client_name: &str, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<models::TokenResponse, Error<ConnectCallbackError>> {
118 let local_var_configuration = configuration;
119
120 let local_var_client = &local_var_configuration.client;
121
122 let local_var_uri_str = format!("{}/oauth/connect_callback/{client_name}", local_var_configuration.base_path, client_name=crate::apis::urlencode(client_name));
123 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
124
125 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
126 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
127 }
128 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
129 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
130 };
131 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
132
133 let local_var_req = local_var_req_builder.build()?;
134 let local_var_resp = local_var_client.execute(local_var_req).await?;
135
136 let local_var_status = local_var_resp.status();
137 let local_var_content = local_var_resp.text().await?;
138
139 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
140 crate::from_str_patched(&local_var_content).map_err(Error::from)
141 } else {
142 let local_var_entity: Option<ConnectCallbackError> = crate::from_str_patched(&local_var_content).ok();
143 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
144 Err(Error::ResponseError(local_var_error))
145 }
146}
147
148pub async fn connect_client_credentials(configuration: &configuration::Configuration, client: &str, connect_client_credentials_request: models::ConnectClientCredentialsRequest) -> Result<models::TokenResponse, Error<ConnectClientCredentialsError>> {
149 let local_var_configuration = configuration;
150
151 let local_var_client = &local_var_configuration.client;
152
153 let local_var_uri_str = format!("{}/oauth/connect_client_credentials/{client}", local_var_configuration.base_path, client=crate::apis::urlencode(client));
154 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
155
156 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
157 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
158 }
159 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
160 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
161 };
162 local_var_req_builder = local_var_req_builder.json(&connect_client_credentials_request);
163
164 let local_var_req = local_var_req_builder.build()?;
165 let local_var_resp = local_var_client.execute(local_var_req).await?;
166
167 let local_var_status = local_var_resp.status();
168 let local_var_content = local_var_resp.text().await?;
169
170 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
171 crate::from_str_patched(&local_var_content).map_err(Error::from)
172 } else {
173 let local_var_entity: Option<ConnectClientCredentialsError> = crate::from_str_patched(&local_var_content).ok();
174 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
175 Err(Error::ResponseError(local_var_error))
176 }
177}
178
179pub async fn connect_slack_callback(configuration: &configuration::Configuration, workspace: &str, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<String, Error<ConnectSlackCallbackError>> {
180 let local_var_configuration = configuration;
181
182 let local_var_client = &local_var_configuration.client;
183
184 let local_var_uri_str = format!("{}/w/{workspace}/oauth/connect_slack_callback", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
185 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
186
187 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
188 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
189 }
190 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
191 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
192 };
193 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
194
195 let local_var_req = local_var_req_builder.build()?;
196 let local_var_resp = local_var_client.execute(local_var_req).await?;
197
198 let local_var_status = local_var_resp.status();
199 let local_var_content = local_var_resp.text().await?;
200
201 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
202 crate::from_str_patched(&local_var_content).map_err(Error::from)
203 } else {
204 let local_var_entity: Option<ConnectSlackCallbackError> = crate::from_str_patched(&local_var_content).ok();
205 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
206 Err(Error::ResponseError(local_var_error))
207 }
208}
209
210pub async fn connect_slack_callback_instance(configuration: &configuration::Configuration, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<String, Error<ConnectSlackCallbackInstanceError>> {
211 let local_var_configuration = configuration;
212
213 let local_var_client = &local_var_configuration.client;
214
215 let local_var_uri_str = format!("{}/oauth/connect_slack_callback", local_var_configuration.base_path);
216 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
217
218 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
219 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
220 }
221 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
222 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
223 };
224 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
225
226 let local_var_req = local_var_req_builder.build()?;
227 let local_var_resp = local_var_client.execute(local_var_req).await?;
228
229 let local_var_status = local_var_resp.status();
230 let local_var_content = local_var_resp.text().await?;
231
232 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
233 crate::from_str_patched(&local_var_content).map_err(Error::from)
234 } else {
235 let local_var_entity: Option<ConnectSlackCallbackInstanceError> = crate::from_str_patched(&local_var_content).ok();
236 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
237 Err(Error::ResponseError(local_var_error))
238 }
239}
240
241pub async fn connect_slack_initiate(configuration: &configuration::Configuration, workspace: &str) -> Result<(), Error<ConnectSlackInitiateError>> {
242 let local_var_configuration = configuration;
243
244 let local_var_client = &local_var_configuration.client;
245
246 let local_var_uri_str = format!("{}/w/{workspace}/oauth/connect_slack", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
247 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
248
249 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
250 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
251 }
252 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
253 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
254 };
255
256 let local_var_req = local_var_req_builder.build()?;
257 let local_var_resp = local_var_client.execute(local_var_req).await?;
258
259 let local_var_status = local_var_resp.status();
260 let local_var_content = local_var_resp.text().await?;
261
262 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
263 Ok(())
264 } else {
265 let local_var_entity: Option<ConnectSlackInitiateError> = crate::from_str_patched(&local_var_content).ok();
266 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
267 Err(Error::ResponseError(local_var_error))
268 }
269}
270
271pub async fn connect_slack_instance(configuration: &configuration::Configuration, connect_slack_request: models::ConnectSlackRequest) -> Result<(), Error<ConnectSlackInstanceError>> {
272 let local_var_configuration = configuration;
273
274 let local_var_client = &local_var_configuration.client;
275
276 let local_var_uri_str = format!("{}/oauth/connect_slack_instance", local_var_configuration.base_path);
277 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
278
279 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
280 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
281 }
282 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
283 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
284 };
285 local_var_req_builder = local_var_req_builder.json(&connect_slack_request);
286
287 let local_var_req = local_var_req_builder.build()?;
288 let local_var_resp = local_var_client.execute(local_var_req).await?;
289
290 let local_var_status = local_var_resp.status();
291 let local_var_content = local_var_resp.text().await?;
292
293 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
294 Ok(())
295 } else {
296 let local_var_entity: Option<ConnectSlackInstanceError> = crate::from_str_patched(&local_var_content).ok();
297 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
298 Err(Error::ResponseError(local_var_error))
299 }
300}
301
302pub async fn create_account(configuration: &configuration::Configuration, workspace: &str, create_account_request: models::CreateAccountRequest) -> Result<String, Error<CreateAccountError>> {
303 let local_var_configuration = configuration;
304
305 let local_var_client = &local_var_configuration.client;
306
307 let local_var_uri_str = format!("{}/w/{workspace}/oauth/create_account", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
308 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, 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 = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
312 }
313 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
314 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
315 };
316 local_var_req_builder = local_var_req_builder.json(&create_account_request);
317
318 let local_var_req = local_var_req_builder.build()?;
319 let local_var_resp = local_var_client.execute(local_var_req).await?;
320
321 let local_var_status = local_var_resp.status();
322 let local_var_content = local_var_resp.text().await?;
323
324 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
325 crate::from_str_patched(&local_var_content).map_err(Error::from)
326 } else {
327 let local_var_entity: Option<CreateAccountError> = crate::from_str_patched(&local_var_content).ok();
328 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
329 Err(Error::ResponseError(local_var_error))
330 }
331}
332
333pub async fn disconnect_account(configuration: &configuration::Configuration, workspace: &str, id: i32) -> Result<String, Error<DisconnectAccountError>> {
334 let local_var_configuration = configuration;
335
336 let local_var_client = &local_var_configuration.client;
337
338 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=id);
339 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
340
341 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
342 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
343 }
344 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
345 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
346 };
347
348 let local_var_req = local_var_req_builder.build()?;
349 let local_var_resp = local_var_client.execute(local_var_req).await?;
350
351 let local_var_status = local_var_resp.status();
352 let local_var_content = local_var_resp.text().await?;
353
354 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
355 crate::from_str_patched(&local_var_content).map_err(Error::from)
356 } else {
357 let local_var_entity: Option<DisconnectAccountError> = crate::from_str_patched(&local_var_content).ok();
358 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
359 Err(Error::ResponseError(local_var_error))
360 }
361}
362
363pub async fn disconnect_slack(configuration: &configuration::Configuration, workspace: &str) -> Result<String, Error<DisconnectSlackError>> {
364 let local_var_configuration = configuration;
365
366 let local_var_client = &local_var_configuration.client;
367
368 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect_slack", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
369 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
370
371 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
372 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
373 }
374 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
375 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
376 };
377
378 let local_var_req = local_var_req_builder.build()?;
379 let local_var_resp = local_var_client.execute(local_var_req).await?;
380
381 let local_var_status = local_var_resp.status();
382 let local_var_content = local_var_resp.text().await?;
383
384 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
385 crate::from_str_patched(&local_var_content).map_err(Error::from)
386 } else {
387 let local_var_entity: Option<DisconnectSlackError> = crate::from_str_patched(&local_var_content).ok();
388 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
389 Err(Error::ResponseError(local_var_error))
390 }
391}
392
393pub async fn disconnect_teams(configuration: &configuration::Configuration, workspace: &str) -> Result<String, Error<DisconnectTeamsError>> {
394 let local_var_configuration = configuration;
395
396 let local_var_client = &local_var_configuration.client;
397
398 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect_teams", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
399 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
400
401 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
402 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
403 }
404 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
405 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
406 };
407
408 let local_var_req = local_var_req_builder.build()?;
409 let local_var_resp = local_var_client.execute(local_var_req).await?;
410
411 let local_var_status = local_var_resp.status();
412 let local_var_content = local_var_resp.text().await?;
413
414 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
415 crate::from_str_patched(&local_var_content).map_err(Error::from)
416 } else {
417 let local_var_entity: Option<DisconnectTeamsError> = crate::from_str_patched(&local_var_content).ok();
418 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
419 Err(Error::ResponseError(local_var_error))
420 }
421}
422
423pub async fn get_o_auth_connect(configuration: &configuration::Configuration, client: &str) -> Result<models::GetOAuthConnect200Response, Error<GetOAuthConnectError>> {
424 let local_var_configuration = configuration;
425
426 let local_var_client = &local_var_configuration.client;
427
428 let local_var_uri_str = format!("{}/oauth/get_connect/{client}", local_var_configuration.base_path, client=crate::apis::urlencode(client));
429 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
430
431 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
432 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
433 }
434 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
435 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
436 };
437
438 let local_var_req = local_var_req_builder.build()?;
439 let local_var_resp = local_var_client.execute(local_var_req).await?;
440
441 let local_var_status = local_var_resp.status();
442 let local_var_content = local_var_resp.text().await?;
443
444 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
445 crate::from_str_patched(&local_var_content).map_err(Error::from)
446 } else {
447 let local_var_entity: Option<GetOAuthConnectError> = crate::from_str_patched(&local_var_content).ok();
448 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
449 Err(Error::ResponseError(local_var_error))
450 }
451}
452
453pub async fn list_o_auth_connects(configuration: &configuration::Configuration, ) -> Result<Vec<String>, Error<ListOAuthConnectsError>> {
454 let local_var_configuration = configuration;
455
456 let local_var_client = &local_var_configuration.client;
457
458 let local_var_uri_str = format!("{}/oauth/list_connects", local_var_configuration.base_path);
459 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
460
461 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
462 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
463 }
464 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
465 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
466 };
467
468 let local_var_req = local_var_req_builder.build()?;
469 let local_var_resp = local_var_client.execute(local_var_req).await?;
470
471 let local_var_status = local_var_resp.status();
472 let local_var_content = local_var_resp.text().await?;
473
474 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
475 crate::from_str_patched(&local_var_content).map_err(Error::from)
476 } else {
477 let local_var_entity: Option<ListOAuthConnectsError> = crate::from_str_patched(&local_var_content).ok();
478 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
479 Err(Error::ResponseError(local_var_error))
480 }
481}
482
483pub async fn list_o_auth_logins(configuration: &configuration::Configuration, ) -> Result<models::ListOAuthLogins200Response, Error<ListOAuthLoginsError>> {
484 let local_var_configuration = configuration;
485
486 let local_var_client = &local_var_configuration.client;
487
488 let local_var_uri_str = format!("{}/oauth/list_logins", local_var_configuration.base_path);
489 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
490
491 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
492 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
493 }
494 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
495 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
496 };
497
498 let local_var_req = local_var_req_builder.build()?;
499 let local_var_resp = local_var_client.execute(local_var_req).await?;
500
501 let local_var_status = local_var_resp.status();
502 let local_var_content = local_var_resp.text().await?;
503
504 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
505 crate::from_str_patched(&local_var_content).map_err(Error::from)
506 } else {
507 let local_var_entity: Option<ListOAuthLoginsError> = crate::from_str_patched(&local_var_content).ok();
508 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
509 Err(Error::ResponseError(local_var_error))
510 }
511}
512
513pub async fn refresh_token(configuration: &configuration::Configuration, workspace: &str, id: i32, refresh_token_request: models::RefreshTokenRequest) -> Result<String, Error<RefreshTokenError>> {
514 let local_var_configuration = configuration;
515
516 let local_var_client = &local_var_configuration.client;
517
518 let local_var_uri_str = format!("{}/w/{workspace}/oauth/refresh_token/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=id);
519 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
520
521 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
522 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
523 }
524 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
525 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
526 };
527 local_var_req_builder = local_var_req_builder.json(&refresh_token_request);
528
529 let local_var_req = local_var_req_builder.build()?;
530 let local_var_resp = local_var_client.execute(local_var_req).await?;
531
532 let local_var_status = local_var_resp.status();
533 let local_var_content = local_var_resp.text().await?;
534
535 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
536 crate::from_str_patched(&local_var_content).map_err(Error::from)
537 } else {
538 let local_var_entity: Option<RefreshTokenError> = crate::from_str_patched(&local_var_content).ok();
539 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
540 Err(Error::ResponseError(local_var_error))
541 }
542}
543