1use std::sync::Arc;
2
3use serde::{Deserialize, Serialize};
4use serde_json::Value;
5
6use crate::models::{ArtifactsResponse, CursorParams, EventsResponse, JsonMap, ResourceList};
7use crate::openapi_paths;
8use crate::transport::Transport;
9use crate::types::Result;
10
11#[derive(Debug, Clone, Serialize, Deserialize, Default)]
12pub struct PoolUpload {
13 #[serde(default)]
14 pub upload_id: Option<String>,
15 #[serde(default)]
16 pub id: Option<String>,
17 #[serde(default)]
18 pub status: Option<String>,
19 #[serde(flatten)]
20 pub extra: JsonMap,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize, Default)]
24pub struct PoolUploadCreateRequest {
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub source: Option<String>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub path: Option<String>,
29 #[serde(flatten)]
30 pub extra: JsonMap,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize, Default)]
34pub struct PoolDataSource {
35 #[serde(default)]
36 pub data_source_id: Option<String>,
37 #[serde(default)]
38 pub id: Option<String>,
39 #[serde(default)]
40 pub status: Option<String>,
41 #[serde(flatten)]
42 pub extra: JsonMap,
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize, Default)]
46pub struct PoolDataSourceCreateRequest {
47 #[serde(skip_serializing_if = "Option::is_none")]
48 pub upload_id: Option<String>,
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub name: Option<String>,
51 #[serde(flatten)]
52 pub extra: JsonMap,
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize, Default)]
56pub struct PoolDataSourceUpdateRequest {
57 #[serde(skip_serializing_if = "Option::is_none")]
58 pub name: Option<String>,
59 #[serde(skip_serializing_if = "Option::is_none")]
60 pub status: Option<String>,
61 #[serde(flatten)]
62 pub extra: JsonMap,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize, Default)]
66pub struct PoolAssembly {
67 #[serde(default)]
68 pub assembly_id: Option<String>,
69 #[serde(default)]
70 pub id: Option<String>,
71 #[serde(default)]
72 pub status: Option<String>,
73 #[serde(flatten)]
74 pub extra: JsonMap,
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize, Default)]
78pub struct PoolAssemblyCreateRequest {
79 #[serde(skip_serializing_if = "Option::is_none")]
80 pub data_source_id: Option<String>,
81 #[serde(skip_serializing_if = "Option::is_none")]
82 pub name: Option<String>,
83 #[serde(flatten)]
84 pub extra: JsonMap,
85}
86
87#[derive(Debug, Clone, Serialize, Deserialize, Default)]
88pub struct Pool {
89 #[serde(default)]
90 pub pool_id: Option<String>,
91 #[serde(default)]
92 pub id: Option<String>,
93 #[serde(default)]
94 pub status: Option<String>,
95 #[serde(flatten)]
96 pub extra: JsonMap,
97}
98
99#[derive(Debug, Clone, Serialize, Deserialize, Default)]
100pub struct PoolCreateRequest {
101 #[serde(skip_serializing_if = "Option::is_none")]
102 pub name: Option<String>,
103 #[serde(skip_serializing_if = "Option::is_none")]
104 pub target: Option<String>,
105 #[serde(flatten)]
106 pub extra: JsonMap,
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize, Default)]
110pub struct PoolUpdateRequest {
111 #[serde(skip_serializing_if = "Option::is_none")]
112 pub name: Option<String>,
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub status: Option<String>,
115 #[serde(flatten)]
116 pub extra: JsonMap,
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize, Default)]
120pub struct PoolRollout {
121 #[serde(default)]
122 pub rollout_id: Option<String>,
123 #[serde(default)]
124 pub id: Option<String>,
125 #[serde(default)]
126 pub status: Option<String>,
127 #[serde(flatten)]
128 pub extra: JsonMap,
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize, Default)]
132pub struct PoolRolloutCreateRequest {
133 #[serde(skip_serializing_if = "Option::is_none")]
134 pub policy: Option<Value>,
135 #[serde(skip_serializing_if = "Option::is_none")]
136 pub input: Option<Value>,
137 #[serde(flatten)]
138 pub extra: JsonMap,
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize, Default)]
142pub struct PoolTask {
143 #[serde(default)]
144 pub task_id: Option<String>,
145 #[serde(default)]
146 pub id: Option<String>,
147 #[serde(default)]
148 pub status: Option<String>,
149 #[serde(flatten)]
150 pub extra: JsonMap,
151}
152
153#[derive(Debug, Clone, Serialize, Deserialize, Default)]
154pub struct PoolTaskCreateRequest {
155 #[serde(skip_serializing_if = "Option::is_none")]
156 pub name: Option<String>,
157 #[serde(skip_serializing_if = "Option::is_none")]
158 pub config: Option<Value>,
159 #[serde(flatten)]
160 pub extra: JsonMap,
161}
162
163#[derive(Debug, Clone, Serialize, Deserialize, Default)]
164pub struct PoolTaskUpdateRequest {
165 #[serde(skip_serializing_if = "Option::is_none")]
166 pub name: Option<String>,
167 #[serde(skip_serializing_if = "Option::is_none")]
168 pub config: Option<Value>,
169 #[serde(flatten)]
170 pub extra: JsonMap,
171}
172
173#[derive(Debug, Clone, Serialize, Deserialize, Default)]
174pub struct PoolMetricsResponse {
175 #[serde(default)]
176 pub metrics: Option<Value>,
177 #[serde(flatten)]
178 pub extra: JsonMap,
179}
180
181#[derive(Debug, Clone, Serialize, Deserialize, Default)]
182pub struct TopLevelRollout {
183 #[serde(default)]
184 pub rollout_id: Option<String>,
185 #[serde(default)]
186 pub id: Option<String>,
187 #[serde(default)]
188 pub status: Option<String>,
189 #[serde(flatten)]
190 pub extra: JsonMap,
191}
192
193#[derive(Debug, Clone, Serialize, Deserialize, Default)]
194pub struct TopLevelRolloutCreateRequest {
195 #[serde(skip_serializing_if = "Option::is_none")]
196 pub policy: Option<Value>,
197 #[serde(skip_serializing_if = "Option::is_none")]
198 pub input: Option<Value>,
199 #[serde(flatten)]
200 pub extra: JsonMap,
201}
202
203#[derive(Clone)]
204pub struct PoolsClient {
205 transport: Arc<Transport>,
206}
207
208impl PoolsClient {
209 pub(crate) fn new(transport: Arc<Transport>) -> Self {
210 Self { transport }
211 }
212
213 pub fn uploads(&self) -> PoolUploadsClient {
214 PoolUploadsClient {
215 transport: self.transport.clone(),
216 }
217 }
218
219 pub fn data_sources(&self) -> PoolDataSourcesClient {
220 PoolDataSourcesClient {
221 transport: self.transport.clone(),
222 }
223 }
224
225 pub fn assemblies(&self) -> PoolAssembliesClient {
226 PoolAssembliesClient {
227 transport: self.transport.clone(),
228 }
229 }
230
231 pub fn rollouts(&self) -> TopLevelRolloutsClient {
232 TopLevelRolloutsClient {
233 transport: self.transport.clone(),
234 }
235 }
236
237 pub async fn create(&self, request: &PoolCreateRequest) -> Result<Pool> {
238 self.transport.post_json(openapi_paths::V1_POOLS, request).await
239 }
240
241 pub async fn list(&self, params: Option<&CursorParams>) -> Result<ResourceList<Pool>> {
242 match params {
243 Some(query) => self
244 .transport
245 .get_json_with_query(openapi_paths::V1_POOLS, query)
246 .await,
247 None => self.transport.get_json(openapi_paths::V1_POOLS).await,
248 }
249 }
250
251 pub async fn get(&self, pool_id: &str) -> Result<Pool> {
252 self.transport
253 .get_json(&openapi_paths::v1_pool(pool_id))
254 .await
255 }
256
257 pub async fn update(&self, pool_id: &str, request: &PoolUpdateRequest) -> Result<Pool> {
258 self.transport
259 .patch_json(&openapi_paths::v1_pool(pool_id), request)
260 .await
261 }
262
263 pub async fn delete(&self, pool_id: &str) -> Result<()> {
264 self.transport
265 .delete_empty(&openapi_paths::v1_pool(pool_id))
266 .await
267 }
268
269 pub async fn create_pool_assembly(
270 &self,
271 pool_id: &str,
272 request: &PoolAssemblyCreateRequest,
273 ) -> Result<PoolAssembly> {
274 self.transport
275 .post_json(&openapi_paths::v1_pool_assemblies(pool_id), request)
276 .await
277 }
278
279 pub fn pool_rollouts(&self, pool_id: impl Into<String>) -> PoolRolloutsClient {
280 PoolRolloutsClient {
281 transport: self.transport.clone(),
282 pool_id: pool_id.into(),
283 }
284 }
285
286 pub fn pool_tasks(&self, pool_id: impl Into<String>) -> PoolTasksClient {
287 PoolTasksClient {
288 transport: self.transport.clone(),
289 pool_id: pool_id.into(),
290 }
291 }
292
293 pub async fn metrics(&self, pool_id: &str) -> Result<PoolMetricsResponse> {
294 self.transport
295 .get_json(&openapi_paths::v1_pool_metrics(pool_id))
296 .await
297 }
298}
299
300#[derive(Clone)]
301pub struct PoolUploadsClient {
302 transport: Arc<Transport>,
303}
304
305impl PoolUploadsClient {
306 pub async fn create(&self, request: &PoolUploadCreateRequest) -> Result<PoolUpload> {
307 self.transport
308 .post_json(openapi_paths::V1_POOLS_UPLOADS, request)
309 .await
310 }
311
312 pub async fn get(&self, upload_id: &str) -> Result<PoolUpload> {
313 self.transport
314 .get_json(&openapi_paths::v1_pools_upload(upload_id))
315 .await
316 }
317}
318
319#[derive(Clone)]
320pub struct PoolDataSourcesClient {
321 transport: Arc<Transport>,
322}
323
324impl PoolDataSourcesClient {
325 pub async fn create(&self, request: &PoolDataSourceCreateRequest) -> Result<PoolDataSource> {
326 self.transport
327 .post_json(openapi_paths::V1_POOLS_DATA_SOURCES, request)
328 .await
329 }
330
331 pub async fn list(&self, params: Option<&CursorParams>) -> Result<ResourceList<PoolDataSource>> {
332 match params {
333 Some(query) => self
334 .transport
335 .get_json_with_query(openapi_paths::V1_POOLS_DATA_SOURCES, query)
336 .await,
337 None => self
338 .transport
339 .get_json(openapi_paths::V1_POOLS_DATA_SOURCES)
340 .await,
341 }
342 }
343
344 pub async fn get(&self, data_source_id: &str) -> Result<PoolDataSource> {
345 self.transport
346 .get_json(&openapi_paths::v1_pools_data_source(data_source_id))
347 .await
348 }
349
350 pub async fn update(
351 &self,
352 data_source_id: &str,
353 request: &PoolDataSourceUpdateRequest,
354 ) -> Result<PoolDataSource> {
355 self.transport
356 .patch_json(&openapi_paths::v1_pools_data_source(data_source_id), request)
357 .await
358 }
359
360 pub async fn refresh(&self, data_source_id: &str) -> Result<PoolDataSource> {
361 self.transport
362 .post_json(
363 &openapi_paths::v1_pools_data_source_refresh(data_source_id),
364 &serde_json::json!({}),
365 )
366 .await
367 }
368}
369
370#[derive(Clone)]
371pub struct PoolAssembliesClient {
372 transport: Arc<Transport>,
373}
374
375impl PoolAssembliesClient {
376 pub async fn create(&self, request: &PoolAssemblyCreateRequest) -> Result<PoolAssembly> {
377 self.transport
378 .post_json(openapi_paths::V1_POOLS_ASSEMBLIES, request)
379 .await
380 }
381
382 pub async fn list(&self, params: Option<&CursorParams>) -> Result<ResourceList<PoolAssembly>> {
383 match params {
384 Some(query) => self
385 .transport
386 .get_json_with_query(openapi_paths::V1_POOLS_ASSEMBLIES, query)
387 .await,
388 None => self
389 .transport
390 .get_json(openapi_paths::V1_POOLS_ASSEMBLIES)
391 .await,
392 }
393 }
394
395 pub async fn get(&self, assembly_id: &str) -> Result<PoolAssembly> {
396 self.transport
397 .get_json(&openapi_paths::v1_pools_assembly(assembly_id))
398 .await
399 }
400
401 pub async fn events(&self, assembly_id: &str, params: Option<&CursorParams>) -> Result<EventsResponse> {
402 let path = openapi_paths::v1_pools_assembly_events(assembly_id);
403 match params {
404 Some(query) => self.transport.get_json_with_query(&path, query).await,
405 None => self.transport.get_json(&path).await,
406 }
407 }
408}
409
410#[derive(Clone)]
411pub struct PoolRolloutsClient {
412 transport: Arc<Transport>,
413 pool_id: String,
414}
415
416impl PoolRolloutsClient {
417 pub async fn create(&self, request: &PoolRolloutCreateRequest) -> Result<PoolRollout> {
418 self.transport
419 .post_json(&openapi_paths::v1_pool_rollouts(&self.pool_id), request)
420 .await
421 }
422
423 pub async fn list(&self, params: Option<&CursorParams>) -> Result<ResourceList<PoolRollout>> {
424 let path = openapi_paths::v1_pool_rollouts(&self.pool_id);
425 match params {
426 Some(query) => self.transport.get_json_with_query(&path, query).await,
427 None => self.transport.get_json(&path).await,
428 }
429 }
430
431 pub async fn get(&self, rollout_id: &str) -> Result<PoolRollout> {
432 self.transport
433 .get_json(&openapi_paths::v1_pool_rollout(&self.pool_id, rollout_id))
434 .await
435 }
436
437 pub async fn cancel(&self, rollout_id: &str) -> Result<PoolRollout> {
438 self.transport
439 .post_json(
440 &openapi_paths::v1_pool_rollout_cancel(&self.pool_id, rollout_id),
441 &serde_json::json!({}),
442 )
443 .await
444 }
445
446 pub async fn artifacts(&self, rollout_id: &str) -> Result<ArtifactsResponse> {
447 self.transport
448 .get_json(&openapi_paths::v1_pool_rollout_artifacts(&self.pool_id, rollout_id))
449 .await
450 }
451
452 pub async fn usage(&self, rollout_id: &str) -> Result<Value> {
453 self.transport
454 .get_json(&openapi_paths::v1_pool_rollout_usage(&self.pool_id, rollout_id))
455 .await
456 }
457
458 pub async fn events(&self, rollout_id: &str, params: Option<&CursorParams>) -> Result<EventsResponse> {
459 let path = openapi_paths::v1_pool_rollout_events(&self.pool_id, rollout_id);
460 match params {
461 Some(query) => self.transport.get_json_with_query(&path, query).await,
462 None => self.transport.get_json(&path).await,
463 }
464 }
465}
466
467#[derive(Clone)]
468pub struct PoolTasksClient {
469 transport: Arc<Transport>,
470 pool_id: String,
471}
472
473impl PoolTasksClient {
474 pub async fn list(&self, params: Option<&CursorParams>) -> Result<ResourceList<PoolTask>> {
475 let path = openapi_paths::v1_pool_tasks(&self.pool_id);
476 match params {
477 Some(query) => self.transport.get_json_with_query(&path, query).await,
478 None => self.transport.get_json(&path).await,
479 }
480 }
481
482 pub async fn create(&self, request: &PoolTaskCreateRequest) -> Result<PoolTask> {
483 self.transport
484 .post_json(&openapi_paths::v1_pool_tasks(&self.pool_id), request)
485 .await
486 }
487
488 pub async fn update(&self, task_id: &str, request: &PoolTaskUpdateRequest) -> Result<PoolTask> {
489 self.transport
490 .put_json(&openapi_paths::v1_pool_task(&self.pool_id, task_id), request)
491 .await
492 }
493
494 pub async fn delete(&self, task_id: &str) -> Result<()> {
495 self.transport
496 .delete_empty(&openapi_paths::v1_pool_task(&self.pool_id, task_id))
497 .await
498 }
499}
500
501#[derive(Clone)]
502pub struct TopLevelRolloutsClient {
503 transport: Arc<Transport>,
504}
505
506impl TopLevelRolloutsClient {
507 pub async fn create(&self, request: &TopLevelRolloutCreateRequest) -> Result<TopLevelRollout> {
508 self.transport.post_json(openapi_paths::V1_ROLLOUTS, request).await
509 }
510
511 pub async fn get(&self, rollout_id: &str) -> Result<TopLevelRollout> {
512 self.transport
513 .get_json(&openapi_paths::v1_rollout(rollout_id))
514 .await
515 }
516
517 pub async fn artifacts(&self, rollout_id: &str) -> Result<ArtifactsResponse> {
518 self.transport
519 .get_json(&openapi_paths::v1_rollout_artifacts(rollout_id))
520 .await
521 }
522
523 pub async fn artifacts_zip(&self, rollout_id: &str) -> Result<Vec<u8>> {
524 self.transport
525 .get_bytes(&openapi_paths::v1_rollout_artifacts_zip(rollout_id))
526 .await
527 }
528
529 pub async fn artifact_path(&self, rollout_id: &str, path: &str) -> Result<Vec<u8>> {
530 self.transport
531 .get_bytes(&openapi_paths::v1_rollout_artifact_path(rollout_id, path))
532 .await
533 }
534
535 pub async fn support_bundle(&self, rollout_id: &str) -> Result<Vec<u8>> {
536 self.transport
537 .get_bytes(&openapi_paths::v1_rollout_support_bundle(rollout_id))
538 .await
539 }
540}