1use reqwest;
12use serde::{Deserialize, Serialize};
13use crate::{models, utils,apis::ResponseContent};
14use super::{Error, configuration};
15
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum CreateDeploymentError {
21 Status412(models::ErrorResponse),
22 Status403(models::ErrorResponse),
23 Status400(models::ErrorResponse),
24 UnknownValue(serde_json::Value),
25}
26
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum DeleteDeploymentError {
32 Status403(models::ErrorResponse),
33 Status409(models::ErrorResponse),
34 Status404(models::ErrorResponse),
35 UnknownValue(serde_json::Value),
36}
37
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum GetDeploymentError {
43 Status404(models::ErrorResponse),
44 UnknownValue(serde_json::Value),
45}
46
47
48#[derive(Debug, Clone, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum GetDeploymentLogsError {
52 Status500(models::ErrorResponse),
53 Status404(models::ErrorResponse),
54 Status400(models::ErrorResponse),
55 UnknownValue(serde_json::Value),
56}
57
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum GetInferenceEngineHelpError {
63 UnknownValue(serde_json::Value),
64}
65
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum ListAiInstanceTypesError {
71 UnknownValue(serde_json::Value),
72}
73
74
75#[derive(Debug, Clone, Serialize, Deserialize)]
77#[serde(untagged)]
78pub enum ListDeploymentsError {
79 Status400(models::ErrorResponse),
80 UnknownValue(serde_json::Value),
81}
82
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum RevealDeploymentApiKeyError {
88 Status404(models::ErrorResponse),
89 UnknownValue(serde_json::Value),
90}
91
92
93#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum ScaleDeploymentError {
97 Status412(models::ErrorResponse),
98 Status403(models::ErrorResponse),
99 Status409(models::ErrorResponse),
100 Status404(models::ErrorResponse),
101 UnknownValue(serde_json::Value),
102}
103
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum UpdateDeploymentError {
109 Status403(models::ErrorResponse),
110 Status409(models::ErrorResponse),
111 Status404(models::ErrorResponse),
112 Status400(models::ErrorResponse),
113 UnknownValue(serde_json::Value),
114}
115
116
117pub async fn create_deployment(configuration: &configuration::Configuration, create_deployment_request: models::CreateDeploymentRequest) -> Result<models::Operation, Error<CreateDeploymentError>> {
118 let local_var_create_deployment_request = create_deployment_request;
119
120 let path_params_map = std::collections::HashMap::new();
121
122 let query_params_vec: Vec<(&str, String)> = Vec::new();
123 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
124 let body_payload_option = Some(local_var_create_deployment_request);
125
126 utils::execute_request(
127 configuration,
128 reqwest::Method::POST,
129 "/ai/deployment",
130 path_params_map,
131 query_params_option,
132 body_payload_option,
133 ).await
134}
135pub async fn delete_deployment(configuration: &configuration::Configuration, id: String) -> Result<models::Operation, Error<DeleteDeploymentError>> {
136 let local_var_id = id;
137
138 let mut path_params_map = std::collections::HashMap::new();
139 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
140
141 let query_params_vec: Vec<(&str, String)> = Vec::new();
142 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
143 let body_payload_option: Option<()> = None;
144
145 utils::execute_request(
146 configuration,
147 reqwest::Method::DELETE,
148 "/ai/deployment/{id}",
149 path_params_map,
150 query_params_option,
151 body_payload_option,
152 ).await
153}
154pub async fn get_deployment(configuration: &configuration::Configuration, id: String) -> Result<models::GetDeploymentResponse, Error<GetDeploymentError>> {
155 let local_var_id = id;
156
157 let mut path_params_map = std::collections::HashMap::new();
158 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
159
160 let query_params_vec: Vec<(&str, String)> = Vec::new();
161 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
162 let body_payload_option: Option<()> = None;
163
164 utils::execute_request(
165 configuration,
166 reqwest::Method::GET,
167 "/ai/deployment/{id}",
168 path_params_map,
169 query_params_option,
170 body_payload_option,
171 ).await
172}
173pub async fn get_deployment_logs(configuration: &configuration::Configuration, id: String, stream: Option<bool>, tail: Option<i64>) -> Result<models::GetDeploymentLogsResponse, Error<GetDeploymentLogsError>> {
174 let local_var_id = id;
175 let local_var_stream = stream;
176 let local_var_tail = tail;
177
178 let mut path_params_map = std::collections::HashMap::new();
179 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
180
181 let mut query_params_vec: Vec<(&str, String)> = Vec::new();
182 if let Some(value) = &local_var_stream {
183 query_params_vec.push(("stream", value.to_string()));
184 }
185 if let Some(value) = &local_var_tail {
186 query_params_vec.push(("tail", value.to_string()));
187 }
188 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
189 let body_payload_option: Option<()> = None;
190
191 utils::execute_request(
192 configuration,
193 reqwest::Method::GET,
194 "/ai/deployment/{id}/logs",
195 path_params_map,
196 query_params_option,
197 body_payload_option,
198 ).await
199}
200pub async fn get_inference_engine_help(configuration: &configuration::Configuration, version: Option<&str>) -> Result<models::GetInferenceEngineHelpResponse, Error<GetInferenceEngineHelpError>> {
201 let local_var_version = version;
202
203 let path_params_map = std::collections::HashMap::new();
204
205 let mut query_params_vec: Vec<(&str, String)> = Vec::new();
206 if let Some(value) = &local_var_version {
207 query_params_vec.push(("version", value.to_string()));
208 }
209 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
210 let body_payload_option: Option<()> = None;
211
212 utils::execute_request(
213 configuration,
214 reqwest::Method::GET,
215 "/ai/help/inference-engine-parameters",
216 path_params_map,
217 query_params_option,
218 body_payload_option,
219 ).await
220}
221pub async fn list_ai_instance_types(configuration: &configuration::Configuration, ) -> Result<models::ListAiInstanceTypesResponse, Error<ListAiInstanceTypesError>> {
222
223 let path_params_map = std::collections::HashMap::new();
224
225 let query_params_vec: Vec<(&str, String)> = Vec::new();
226 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
227 let body_payload_option: Option<()> = None;
228
229 utils::execute_request(
230 configuration,
231 reqwest::Method::GET,
232 "/ai/instance-type",
233 path_params_map,
234 query_params_option,
235 body_payload_option,
236 ).await
237}
238pub async fn list_deployments(configuration: &configuration::Configuration, visibility: Option<&str>) -> Result<models::ListDeploymentsResponse, Error<ListDeploymentsError>> {
239 let local_var_visibility = visibility;
240
241 let path_params_map = std::collections::HashMap::new();
242
243 let mut query_params_vec: Vec<(&str, String)> = Vec::new();
244 if let Some(value) = &local_var_visibility {
245 query_params_vec.push(("visibility", value.to_string()));
246 }
247 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
248 let body_payload_option: Option<()> = None;
249
250 utils::execute_request(
251 configuration,
252 reqwest::Method::GET,
253 "/ai/deployment",
254 path_params_map,
255 query_params_option,
256 body_payload_option,
257 ).await
258}
259pub async fn reveal_deployment_api_key(configuration: &configuration::Configuration, id: String) -> Result<models::RevealDeploymentApiKeyResponse, Error<RevealDeploymentApiKeyError>> {
260 let local_var_id = id;
261
262 let mut path_params_map = std::collections::HashMap::new();
263 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
264
265 let query_params_vec: Vec<(&str, String)> = Vec::new();
266 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
267 let body_payload_option: Option<()> = None;
268
269 utils::execute_request(
270 configuration,
271 reqwest::Method::GET,
272 "/ai/deployment/{id}/api-key",
273 path_params_map,
274 query_params_option,
275 body_payload_option,
276 ).await
277}
278pub async fn scale_deployment(configuration: &configuration::Configuration, id: String, scale_deployment_request: models::ScaleDeploymentRequest) -> Result<models::Operation, Error<ScaleDeploymentError>> {
279 let local_var_id = id;
280 let local_var_scale_deployment_request = scale_deployment_request;
281
282 let mut path_params_map = std::collections::HashMap::new();
283 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
284
285 let query_params_vec: Vec<(&str, String)> = Vec::new();
286 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
287 let body_payload_option = Some(local_var_scale_deployment_request);
288
289 utils::execute_request(
290 configuration,
291 reqwest::Method::POST,
292 "/ai/deployment/{id}/scale",
293 path_params_map,
294 query_params_option,
295 body_payload_option,
296 ).await
297}
298pub async fn update_deployment(configuration: &configuration::Configuration, id: String, update_deployment_request: models::UpdateDeploymentRequest) -> Result<models::Operation, Error<UpdateDeploymentError>> {
299 let local_var_id = id;
300 let local_var_update_deployment_request = update_deployment_request;
301
302 let mut path_params_map = std::collections::HashMap::new();
303 path_params_map.insert("id".to_string(), crate::apis::urlencode(local_var_id));
304
305 let query_params_vec: Vec<(&str, String)> = Vec::new();
306 let query_params_option = if query_params_vec.is_empty() { None } else { Some(query_params_vec.as_slice())};
307 let body_payload_option = Some(local_var_update_deployment_request);
308
309 utils::execute_request(
310 configuration,
311 reqwest::Method::PATCH,
312 "/ai/deployment/{id}",
313 path_params_map,
314 query_params_option,
315 body_payload_option,
316 ).await
317}