1use reqwest;
13
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ManagedBlueprintsApplyCreateError {
22 Status400(models::ValidationError),
23 Status403(models::GenericError),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum ManagedBlueprintsAvailableListError {
31 Status400(models::ValidationError),
32 Status403(models::GenericError),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum ManagedBlueprintsCreateError {
40 Status400(models::ValidationError),
41 Status403(models::GenericError),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum ManagedBlueprintsDestroyError {
49 Status400(models::ValidationError),
50 Status403(models::GenericError),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum ManagedBlueprintsListError {
58 Status400(models::ValidationError),
59 Status403(models::GenericError),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum ManagedBlueprintsPartialUpdateError {
67 Status400(models::ValidationError),
68 Status403(models::GenericError),
69 UnknownValue(serde_json::Value),
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum ManagedBlueprintsRetrieveError {
76 Status400(models::ValidationError),
77 Status403(models::GenericError),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum ManagedBlueprintsUpdateError {
85 Status400(models::ValidationError),
86 Status403(models::GenericError),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum ManagedBlueprintsUsedByListError {
94 Status400(models::ValidationError),
95 Status403(models::GenericError),
96 UnknownValue(serde_json::Value),
97}
98
99
100pub async fn managed_blueprints_apply_create(configuration: &configuration::Configuration, instance_uuid: &str) -> Result<models::BlueprintInstance, Error<ManagedBlueprintsApplyCreateError>> {
102 let local_var_configuration = configuration;
103
104 let local_var_client = &local_var_configuration.client;
105
106 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/apply/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
107 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
108
109 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
110 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
111 }
112 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
113 let local_var_key = local_var_apikey.key.clone();
114 let local_var_value = match local_var_apikey.prefix {
115 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
116 None => local_var_key,
117 };
118 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
119 };
120
121 let local_var_req = local_var_req_builder.build()?;
122 let local_var_resp = local_var_client.execute(local_var_req).await?;
123
124 let local_var_status = local_var_resp.status();
125 let local_var_content = local_var_resp.text().await?;
126
127 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
128 serde_json::from_str(&local_var_content).map_err(Error::from)
129 } else {
130 let local_var_entity: Option<ManagedBlueprintsApplyCreateError> = serde_json::from_str(&local_var_content).ok();
131 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
132 Err(Error::ResponseError(local_var_error))
133 }
134}
135
136pub async fn managed_blueprints_available_list(configuration: &configuration::Configuration, ) -> Result<Vec<models::BlueprintFile>, Error<ManagedBlueprintsAvailableListError>> {
138 let local_var_configuration = configuration;
139
140 let local_var_client = &local_var_configuration.client;
141
142 let local_var_uri_str = format!("{}/managed/blueprints/available/", local_var_configuration.base_path);
143 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
144
145 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
146 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
147 }
148 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
149 let local_var_key = local_var_apikey.key.clone();
150 let local_var_value = match local_var_apikey.prefix {
151 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
152 None => local_var_key,
153 };
154 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
155 };
156
157 let local_var_req = local_var_req_builder.build()?;
158 let local_var_resp = local_var_client.execute(local_var_req).await?;
159
160 let local_var_status = local_var_resp.status();
161 let local_var_content = local_var_resp.text().await?;
162
163 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
164 serde_json::from_str(&local_var_content).map_err(Error::from)
165 } else {
166 let local_var_entity: Option<ManagedBlueprintsAvailableListError> = serde_json::from_str(&local_var_content).ok();
167 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
168 Err(Error::ResponseError(local_var_error))
169 }
170}
171
172pub async fn managed_blueprints_create(configuration: &configuration::Configuration, blueprint_instance_request: models::BlueprintInstanceRequest) -> Result<models::BlueprintInstance, Error<ManagedBlueprintsCreateError>> {
174 let local_var_configuration = configuration;
175
176 let local_var_client = &local_var_configuration.client;
177
178 let local_var_uri_str = format!("{}/managed/blueprints/", local_var_configuration.base_path);
179 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
180
181 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
182 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
183 }
184 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
185 let local_var_key = local_var_apikey.key.clone();
186 let local_var_value = match local_var_apikey.prefix {
187 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
188 None => local_var_key,
189 };
190 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
191 };
192 local_var_req_builder = local_var_req_builder.json(&blueprint_instance_request);
193
194 let local_var_req = local_var_req_builder.build()?;
195 let local_var_resp = local_var_client.execute(local_var_req).await?;
196
197 let local_var_status = local_var_resp.status();
198 let local_var_content = local_var_resp.text().await?;
199
200 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
201 serde_json::from_str(&local_var_content).map_err(Error::from)
202 } else {
203 let local_var_entity: Option<ManagedBlueprintsCreateError> = serde_json::from_str(&local_var_content).ok();
204 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
205 Err(Error::ResponseError(local_var_error))
206 }
207}
208
209pub async fn managed_blueprints_destroy(configuration: &configuration::Configuration, instance_uuid: &str) -> Result<(), Error<ManagedBlueprintsDestroyError>> {
211 let local_var_configuration = configuration;
212
213 let local_var_client = &local_var_configuration.client;
214
215 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
216 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, 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_apikey) = local_var_configuration.api_key {
222 let local_var_key = local_var_apikey.key.clone();
223 let local_var_value = match local_var_apikey.prefix {
224 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
225 None => local_var_key,
226 };
227 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
228 };
229
230 let local_var_req = local_var_req_builder.build()?;
231 let local_var_resp = local_var_client.execute(local_var_req).await?;
232
233 let local_var_status = local_var_resp.status();
234 let local_var_content = local_var_resp.text().await?;
235
236 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
237 Ok(())
238 } else {
239 let local_var_entity: Option<ManagedBlueprintsDestroyError> = serde_json::from_str(&local_var_content).ok();
240 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
241 Err(Error::ResponseError(local_var_error))
242 }
243}
244
245pub async fn managed_blueprints_list(configuration: &configuration::Configuration, name: Option<&str>, ordering: Option<&str>, page: Option<i32>, page_size: Option<i32>, path: Option<&str>, search: Option<&str>) -> Result<models::PaginatedBlueprintInstanceList, Error<ManagedBlueprintsListError>> {
247 let local_var_configuration = configuration;
248
249 let local_var_client = &local_var_configuration.client;
250
251 let local_var_uri_str = format!("{}/managed/blueprints/", local_var_configuration.base_path);
252 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
253
254 if let Some(ref local_var_str) = name {
255 local_var_req_builder = local_var_req_builder.query(&[("name", &local_var_str.to_string())]);
256 }
257 if let Some(ref local_var_str) = ordering {
258 local_var_req_builder = local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
259 }
260 if let Some(ref local_var_str) = page {
261 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
262 }
263 if let Some(ref local_var_str) = page_size {
264 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
265 }
266 if let Some(ref local_var_str) = path {
267 local_var_req_builder = local_var_req_builder.query(&[("path", &local_var_str.to_string())]);
268 }
269 if let Some(ref local_var_str) = search {
270 local_var_req_builder = local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
271 }
272 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
273 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
274 }
275 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
276 let local_var_key = local_var_apikey.key.clone();
277 let local_var_value = match local_var_apikey.prefix {
278 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
279 None => local_var_key,
280 };
281 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
282 };
283
284 let local_var_req = local_var_req_builder.build()?;
285 let local_var_resp = local_var_client.execute(local_var_req).await?;
286
287 let local_var_status = local_var_resp.status();
288 let local_var_content = local_var_resp.text().await?;
289
290 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
291 serde_json::from_str(&local_var_content).map_err(Error::from)
292 } else {
293 let local_var_entity: Option<ManagedBlueprintsListError> = serde_json::from_str(&local_var_content).ok();
294 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
295 Err(Error::ResponseError(local_var_error))
296 }
297}
298
299pub async fn managed_blueprints_partial_update(configuration: &configuration::Configuration, instance_uuid: &str, patched_blueprint_instance_request: Option<models::PatchedBlueprintInstanceRequest>) -> Result<models::BlueprintInstance, Error<ManagedBlueprintsPartialUpdateError>> {
301 let local_var_configuration = configuration;
302
303 let local_var_client = &local_var_configuration.client;
304
305 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
306 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
307
308 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
309 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
310 }
311 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
312 let local_var_key = local_var_apikey.key.clone();
313 let local_var_value = match local_var_apikey.prefix {
314 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
315 None => local_var_key,
316 };
317 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
318 };
319 local_var_req_builder = local_var_req_builder.json(&patched_blueprint_instance_request);
320
321 let local_var_req = local_var_req_builder.build()?;
322 let local_var_resp = local_var_client.execute(local_var_req).await?;
323
324 let local_var_status = local_var_resp.status();
325 let local_var_content = local_var_resp.text().await?;
326
327 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
328 serde_json::from_str(&local_var_content).map_err(Error::from)
329 } else {
330 let local_var_entity: Option<ManagedBlueprintsPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
331 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
332 Err(Error::ResponseError(local_var_error))
333 }
334}
335
336pub async fn managed_blueprints_retrieve(configuration: &configuration::Configuration, instance_uuid: &str) -> Result<models::BlueprintInstance, Error<ManagedBlueprintsRetrieveError>> {
338 let local_var_configuration = configuration;
339
340 let local_var_client = &local_var_configuration.client;
341
342 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
343 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
344
345 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
346 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
347 }
348 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
349 let local_var_key = local_var_apikey.key.clone();
350 let local_var_value = match local_var_apikey.prefix {
351 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
352 None => local_var_key,
353 };
354 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
355 };
356
357 let local_var_req = local_var_req_builder.build()?;
358 let local_var_resp = local_var_client.execute(local_var_req).await?;
359
360 let local_var_status = local_var_resp.status();
361 let local_var_content = local_var_resp.text().await?;
362
363 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
364 serde_json::from_str(&local_var_content).map_err(Error::from)
365 } else {
366 let local_var_entity: Option<ManagedBlueprintsRetrieveError> = serde_json::from_str(&local_var_content).ok();
367 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
368 Err(Error::ResponseError(local_var_error))
369 }
370}
371
372pub async fn managed_blueprints_update(configuration: &configuration::Configuration, instance_uuid: &str, blueprint_instance_request: models::BlueprintInstanceRequest) -> Result<models::BlueprintInstance, Error<ManagedBlueprintsUpdateError>> {
374 let local_var_configuration = configuration;
375
376 let local_var_client = &local_var_configuration.client;
377
378 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
379 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
380
381 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
382 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
383 }
384 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
385 let local_var_key = local_var_apikey.key.clone();
386 let local_var_value = match local_var_apikey.prefix {
387 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
388 None => local_var_key,
389 };
390 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
391 };
392 local_var_req_builder = local_var_req_builder.json(&blueprint_instance_request);
393
394 let local_var_req = local_var_req_builder.build()?;
395 let local_var_resp = local_var_client.execute(local_var_req).await?;
396
397 let local_var_status = local_var_resp.status();
398 let local_var_content = local_var_resp.text().await?;
399
400 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
401 serde_json::from_str(&local_var_content).map_err(Error::from)
402 } else {
403 let local_var_entity: Option<ManagedBlueprintsUpdateError> = serde_json::from_str(&local_var_content).ok();
404 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
405 Err(Error::ResponseError(local_var_error))
406 }
407}
408
409pub async fn managed_blueprints_used_by_list(configuration: &configuration::Configuration, instance_uuid: &str) -> Result<Vec<models::UsedBy>, Error<ManagedBlueprintsUsedByListError>> {
411 let local_var_configuration = configuration;
412
413 let local_var_client = &local_var_configuration.client;
414
415 let local_var_uri_str = format!("{}/managed/blueprints/{instance_uuid}/used_by/", local_var_configuration.base_path, instance_uuid=crate::apis::urlencode(instance_uuid));
416 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
417
418 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
419 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
420 }
421 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
422 let local_var_key = local_var_apikey.key.clone();
423 let local_var_value = match local_var_apikey.prefix {
424 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
425 None => local_var_key,
426 };
427 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
428 };
429
430 let local_var_req = local_var_req_builder.build()?;
431 let local_var_resp = local_var_client.execute(local_var_req).await?;
432
433 let local_var_status = local_var_resp.status();
434 let local_var_content = local_var_resp.text().await?;
435
436 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
437 serde_json::from_str(&local_var_content).map_err(Error::from)
438 } else {
439 let local_var_entity: Option<ManagedBlueprintsUsedByListError> = serde_json::from_str(&local_var_content).ok();
440 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
441 Err(Error::ResponseError(local_var_error))
442 }
443}
444