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 CreateWorkspaceError {
22 Status400(models::ErrorGeneric),
23 Status401(models::ErrorGeneric),
24 Status403(models::ErrorGeneric),
25 Status500(models::ErrorGeneric),
26 DefaultResponse(models::ErrorGeneric),
27 UnknownValue(serde_json::Value),
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum CreateWorkspaceApiKeyError {
34 DefaultResponse(models::ErrorGeneric),
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum DeleteWorkspaceApiKeyError {
42 DefaultResponse(models::ErrorGeneric),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum GetWorkspaceError {
50 Status400(models::ErrorGeneric),
51 Status401(models::ErrorGeneric),
52 Status403(models::ErrorGeneric),
53 Status500(models::ErrorGeneric),
54 DefaultResponse(models::ErrorGeneric),
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum ListWorkspaceApiKeysError {
62 DefaultResponse(models::ErrorGeneric),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum ListWorkspaceProjectsError {
70 Status400(models::ErrorGeneric),
71 Status401(models::ErrorGeneric),
72 Status403(models::ErrorGeneric),
73 Status500(models::ErrorGeneric),
74 DefaultResponse(models::ErrorGeneric),
75 UnknownValue(serde_json::Value),
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
80#[serde(untagged)]
81pub enum ListWorkspacesError {
82 Status400(models::ErrorGeneric),
83 Status401(models::ErrorGeneric),
84 Status403(models::ErrorGeneric),
85 Status500(models::ErrorGeneric),
86 DefaultResponse(models::ErrorGeneric),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum UpdateWorkspaceError {
94 Status400(models::ErrorGeneric),
95 Status401(models::ErrorGeneric),
96 Status403(models::ErrorGeneric),
97 Status500(models::ErrorGeneric),
98 DefaultResponse(models::ErrorGeneric),
99 UnknownValue(serde_json::Value),
100}
101
102
103pub async fn create_workspace(configuration: &configuration::Configuration, create_workspace_body: Option<models::CreateWorkspaceBody>) -> Result<models::Workspace, Error<CreateWorkspaceError>> {
104 let local_var_configuration = configuration;
105
106 let local_var_client = &local_var_configuration.client;
107
108 let local_var_uri_str = format!("{}/workspaces", local_var_configuration.base_path);
109 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
110
111 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
112 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
113 }
114 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
115 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
116 };
117 local_var_req_builder = local_var_req_builder.json(&create_workspace_body);
118
119 let local_var_req = local_var_req_builder.build()?;
120 let local_var_resp = local_var_client.execute(local_var_req).await?;
121
122 let local_var_status = local_var_resp.status();
123 let local_var_content = local_var_resp.text().await?;
124
125 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
126 serde_json::from_str(&local_var_content).map_err(Error::from)
127 } else {
128 let local_var_entity: Option<CreateWorkspaceError> = serde_json::from_str(&local_var_content).ok();
129 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
130 Err(Error::ResponseError(local_var_error))
131 }
132}
133
134pub async fn create_workspace_api_key(configuration: &configuration::Configuration, workspace: &str, create_workspace_api_key_body: Option<models::CreateWorkspaceApiKeyBody>) -> Result<models::WorkspaceApiKey, Error<CreateWorkspaceApiKeyError>> {
136 let local_var_configuration = configuration;
137
138 let local_var_client = &local_var_configuration.client;
139
140 let local_var_uri_str = format!("{}/workspaces/{workspace}/tokens", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
141 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
142
143 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
144 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
145 }
146 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
147 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
148 };
149 local_var_req_builder = local_var_req_builder.json(&create_workspace_api_key_body);
150
151 let local_var_req = local_var_req_builder.build()?;
152 let local_var_resp = local_var_client.execute(local_var_req).await?;
153
154 let local_var_status = local_var_resp.status();
155 let local_var_content = local_var_resp.text().await?;
156
157 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
158 serde_json::from_str(&local_var_content).map_err(Error::from)
159 } else {
160 let local_var_entity: Option<CreateWorkspaceApiKeyError> = serde_json::from_str(&local_var_content).ok();
161 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
162 Err(Error::ResponseError(local_var_error))
163 }
164}
165
166pub async fn delete_workspace_api_key(configuration: &configuration::Configuration, workspace: &str, token_id: &str) -> Result<(), Error<DeleteWorkspaceApiKeyError>> {
168 let local_var_configuration = configuration;
169
170 let local_var_client = &local_var_configuration.client;
171
172 let local_var_uri_str = format!("{}/workspaces/{workspace}/tokens/{token_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), token_id=crate::apis::urlencode(token_id));
173 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
174
175 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
176 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
177 }
178 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
179 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
180 };
181
182 let local_var_req = local_var_req_builder.build()?;
183 let local_var_resp = local_var_client.execute(local_var_req).await?;
184
185 let local_var_status = local_var_resp.status();
186 let local_var_content = local_var_resp.text().await?;
187
188 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
189 Ok(())
190 } else {
191 let local_var_entity: Option<DeleteWorkspaceApiKeyError> = serde_json::from_str(&local_var_content).ok();
192 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
193 Err(Error::ResponseError(local_var_error))
194 }
195}
196
197pub async fn get_workspace(configuration: &configuration::Configuration, workspace: &str) -> Result<models::Workspace, Error<GetWorkspaceError>> {
199 let local_var_configuration = configuration;
200
201 let local_var_client = &local_var_configuration.client;
202
203 let local_var_uri_str = format!("{}/workspaces/{workspace}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
204 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
205
206 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
207 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
208 }
209 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
210 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
211 };
212
213 let local_var_req = local_var_req_builder.build()?;
214 let local_var_resp = local_var_client.execute(local_var_req).await?;
215
216 let local_var_status = local_var_resp.status();
217 let local_var_content = local_var_resp.text().await?;
218
219 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
220 serde_json::from_str(&local_var_content).map_err(Error::from)
221 } else {
222 let local_var_entity: Option<GetWorkspaceError> = serde_json::from_str(&local_var_content).ok();
223 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
224 Err(Error::ResponseError(local_var_error))
225 }
226}
227
228pub async fn list_workspace_api_keys(configuration: &configuration::Configuration, workspace: &str) -> Result<Vec<models::WorkspaceApiKey>, Error<ListWorkspaceApiKeysError>> {
230 let local_var_configuration = configuration;
231
232 let local_var_client = &local_var_configuration.client;
233
234 let local_var_uri_str = format!("{}/workspaces/{workspace}/tokens", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
235 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
236
237 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
238 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
239 }
240 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
241 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
242 };
243
244 let local_var_req = local_var_req_builder.build()?;
245 let local_var_resp = local_var_client.execute(local_var_req).await?;
246
247 let local_var_status = local_var_resp.status();
248 let local_var_content = local_var_resp.text().await?;
249
250 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
251 serde_json::from_str(&local_var_content).map_err(Error::from)
252 } else {
253 let local_var_entity: Option<ListWorkspaceApiKeysError> = serde_json::from_str(&local_var_content).ok();
254 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
255 Err(Error::ResponseError(local_var_error))
256 }
257}
258
259pub async fn list_workspace_projects(configuration: &configuration::Configuration, workspace: &str) -> Result<models::ListWorkspaceProjects, Error<ListWorkspaceProjectsError>> {
261 let local_var_configuration = configuration;
262
263 let local_var_client = &local_var_configuration.client;
264
265 let local_var_uri_str = format!("{}/workspaces/{workspace}/projects", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
266 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
267
268 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
269 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
270 }
271 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
272 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
273 };
274
275 let local_var_req = local_var_req_builder.build()?;
276 let local_var_resp = local_var_client.execute(local_var_req).await?;
277
278 let local_var_status = local_var_resp.status();
279 let local_var_content = local_var_resp.text().await?;
280
281 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
282 serde_json::from_str(&local_var_content).map_err(Error::from)
283 } else {
284 let local_var_entity: Option<ListWorkspaceProjectsError> = serde_json::from_str(&local_var_content).ok();
285 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
286 Err(Error::ResponseError(local_var_error))
287 }
288}
289
290pub async fn list_workspaces(configuration: &configuration::Configuration, page_size: Option<i64>, page_token: Option<&str>) -> Result<models::ListWorkspaces, Error<ListWorkspacesError>> {
291 let local_var_configuration = configuration;
292
293 let local_var_client = &local_var_configuration.client;
294
295 let local_var_uri_str = format!("{}/workspaces", local_var_configuration.base_path);
296 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
297
298 if let Some(ref local_var_str) = page_size {
299 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
300 }
301 if let Some(ref local_var_str) = page_token {
302 local_var_req_builder = local_var_req_builder.query(&[("page_token", &local_var_str.to_string())]);
303 }
304 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
305 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
306 }
307 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
308 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
309 };
310
311 let local_var_req = local_var_req_builder.build()?;
312 let local_var_resp = local_var_client.execute(local_var_req).await?;
313
314 let local_var_status = local_var_resp.status();
315 let local_var_content = local_var_resp.text().await?;
316
317 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
318 serde_json::from_str(&local_var_content).map_err(Error::from)
319 } else {
320 let local_var_entity: Option<ListWorkspacesError> = serde_json::from_str(&local_var_content).ok();
321 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
322 Err(Error::ResponseError(local_var_error))
323 }
324}
325
326pub async fn update_workspace(configuration: &configuration::Configuration, workspace: &str, update_workspace_body: Option<models::UpdateWorkspaceBody>) -> Result<models::Workspace, Error<UpdateWorkspaceError>> {
328 let local_var_configuration = configuration;
329
330 let local_var_client = &local_var_configuration.client;
331
332 let local_var_uri_str = format!("{}/workspaces/{workspace}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
333 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
334
335 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
336 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
337 }
338 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
339 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
340 };
341 local_var_req_builder = local_var_req_builder.json(&update_workspace_body);
342
343 let local_var_req = local_var_req_builder.build()?;
344 let local_var_resp = local_var_client.execute(local_var_req).await?;
345
346 let local_var_status = local_var_resp.status();
347 let local_var_content = local_var_resp.text().await?;
348
349 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
350 serde_json::from_str(&local_var_content).map_err(Error::from)
351 } else {
352 let local_var_entity: Option<UpdateWorkspaceError> = serde_json::from_str(&local_var_content).ok();
353 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
354 Err(Error::ResponseError(local_var_error))
355 }
356}
357