spiral/api/storage/
objects.rs

1// Generated by tools/service-contracts/rust.py. Do not edit.
2#![doc = "Generated transport-independent contract objects."]
3
4use std::error::Error as StdError;
5use std::fmt::{self, Display, Formatter};
6
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8use serde_json::Value;
9use spiral_contract::error::{ErrorEnvelope, ServiceError};
10use spiral_contract::strict::{DeserializeStrict, Strict};
11use uuid::Uuid;
12
13/// AwsAccessKey contract value.
14#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
15pub struct AwsAccessKey {
16    /// Contract field accessKeyId.
17    #[serde(rename = "accessKeyId")]
18    pub access_key_id: String,
19    /// Contract field region.
20    #[serde(rename = "region")]
21    #[serde(default, skip_serializing_if = "Option::is_none")]
22    pub region: Option<String>,
23    /// Contract field secretAccessKey.
24    #[serde(rename = "secretAccessKey")]
25    pub secret_access_key: SecretToken,
26}
27impl<'de> DeserializeStrict<'de> for AwsAccessKey {
28    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
29        #[derive(Deserialize)]
30        #[serde(deny_unknown_fields)]
31        struct __Wire {
32            #[serde(rename = "accessKeyId")]
33            access_key_id: Strict<String>,
34            #[serde(rename = "region")]
35            #[serde(default)]
36            region: Strict<Option<String>>,
37            #[serde(rename = "secretAccessKey")]
38            secret_access_key: Strict<SecretToken>,
39        }
40        let wire = __Wire::deserialize(deserializer)?;
41        Ok(Self {
42            access_key_id: wire.access_key_id.0,
43            region: wire.region.0,
44            secret_access_key: wire.secret_access_key.0,
45        })
46    }
47}
48
49/// AwsAccessKeyConfig contract value.
50#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
51pub struct AwsAccessKeyConfig {
52    /// Contract field accessKeyId.
53    #[serde(rename = "accessKeyId")]
54    pub access_key_id: String,
55    /// Contract field region.
56    #[serde(rename = "region")]
57    #[serde(default, skip_serializing_if = "Option::is_none")]
58    pub region: Option<String>,
59}
60impl<'de> DeserializeStrict<'de> for AwsAccessKeyConfig {
61    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
62        #[derive(Deserialize)]
63        #[serde(deny_unknown_fields)]
64        struct __Wire {
65            #[serde(rename = "accessKeyId")]
66            access_key_id: Strict<String>,
67            #[serde(rename = "region")]
68            #[serde(default)]
69            region: Strict<Option<String>>,
70        }
71        let wire = __Wire::deserialize(deserializer)?;
72        Ok(Self {
73            access_key_id: wire.access_key_id.0,
74            region: wire.region.0,
75        })
76    }
77}
78
79/// AwsOidc contract value.
80#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
81pub struct AwsOidc {
82    /// Contract field region.
83    #[serde(rename = "region")]
84    #[serde(default, skip_serializing_if = "Option::is_none")]
85    pub region: Option<String>,
86    /// Contract field roleArn.
87    #[serde(rename = "roleArn")]
88    pub role_arn: String,
89}
90impl<'de> DeserializeStrict<'de> for AwsOidc {
91    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
92        #[derive(Deserialize)]
93        #[serde(deny_unknown_fields)]
94        struct __Wire {
95            #[serde(rename = "region")]
96            #[serde(default)]
97            region: Strict<Option<String>>,
98            #[serde(rename = "roleArn")]
99            role_arn: Strict<String>,
100        }
101        let wire = __Wire::deserialize(deserializer)?;
102        Ok(Self {
103            region: wire.region.0,
104            role_arn: wire.role_arn.0,
105        })
106    }
107}
108
109/// AwsOidcConfig contract value.
110#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
111pub struct AwsOidcConfig {
112    /// Contract field region.
113    #[serde(rename = "region")]
114    #[serde(default, skip_serializing_if = "Option::is_none")]
115    pub region: Option<String>,
116    /// Contract field roleArn.
117    #[serde(rename = "roleArn")]
118    pub role_arn: String,
119}
120impl<'de> DeserializeStrict<'de> for AwsOidcConfig {
121    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
122        #[derive(Deserialize)]
123        #[serde(deny_unknown_fields)]
124        struct __Wire {
125            #[serde(rename = "region")]
126            #[serde(default)]
127            region: Strict<Option<String>>,
128            #[serde(rename = "roleArn")]
129            role_arn: Strict<String>,
130        }
131        let wire = __Wire::deserialize(deserializer)?;
132        Ok(Self {
133            region: wire.region.0,
134            role_arn: wire.role_arn.0,
135        })
136    }
137}
138
139/// BuiltinFileSystem contract value.
140#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
141pub struct BuiltinFileSystem {
142    /// Contract field directory.
143    #[serde(rename = "directory")]
144    pub directory: String,
145    /// Contract field provider.
146    #[serde(rename = "provider")]
147    pub provider: String,
148}
149impl<'de> DeserializeStrict<'de> for BuiltinFileSystem {
150    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
151        #[derive(Deserialize)]
152        #[serde(deny_unknown_fields)]
153        struct __Wire {
154            #[serde(rename = "directory")]
155            directory: Strict<String>,
156            #[serde(rename = "provider")]
157            provider: Strict<String>,
158        }
159        let wire = __Wire::deserialize(deserializer)?;
160        Ok(Self {
161            directory: wire.directory.0,
162            provider: wire.provider.0,
163        })
164    }
165}
166
167/// CephAccessKey contract value.
168#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
169pub struct CephAccessKey {
170    /// Contract field accessKeyId.
171    #[serde(rename = "accessKeyId")]
172    pub access_key_id: String,
173    /// Contract field endpoint.
174    #[serde(rename = "endpoint")]
175    pub endpoint: String,
176    /// Contract field region.
177    #[serde(rename = "region")]
178    #[serde(default, skip_serializing_if = "Option::is_none")]
179    pub region: Option<String>,
180    /// Contract field roleArn.
181    #[serde(rename = "roleArn")]
182    pub role_arn: String,
183    /// Contract field secretAccessKey.
184    #[serde(rename = "secretAccessKey")]
185    pub secret_access_key: SecretToken,
186}
187impl<'de> DeserializeStrict<'de> for CephAccessKey {
188    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
189        #[derive(Deserialize)]
190        #[serde(deny_unknown_fields)]
191        struct __Wire {
192            #[serde(rename = "accessKeyId")]
193            access_key_id: Strict<String>,
194            #[serde(rename = "endpoint")]
195            endpoint: Strict<String>,
196            #[serde(rename = "region")]
197            #[serde(default)]
198            region: Strict<Option<String>>,
199            #[serde(rename = "roleArn")]
200            role_arn: Strict<String>,
201            #[serde(rename = "secretAccessKey")]
202            secret_access_key: Strict<SecretToken>,
203        }
204        let wire = __Wire::deserialize(deserializer)?;
205        Ok(Self {
206            access_key_id: wire.access_key_id.0,
207            endpoint: wire.endpoint.0,
208            region: wire.region.0,
209            role_arn: wire.role_arn.0,
210            secret_access_key: wire.secret_access_key.0,
211        })
212    }
213}
214
215/// CephAccessKeyConfig contract value.
216#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
217pub struct CephAccessKeyConfig {
218    /// Contract field accessKeyId.
219    #[serde(rename = "accessKeyId")]
220    pub access_key_id: String,
221    /// Contract field endpoint.
222    #[serde(rename = "endpoint")]
223    pub endpoint: String,
224    /// Contract field region.
225    #[serde(rename = "region")]
226    #[serde(default, skip_serializing_if = "Option::is_none")]
227    pub region: Option<String>,
228    /// Contract field roleArn.
229    #[serde(rename = "roleArn")]
230    pub role_arn: String,
231}
232impl<'de> DeserializeStrict<'de> for CephAccessKeyConfig {
233    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
234        #[derive(Deserialize)]
235        #[serde(deny_unknown_fields)]
236        struct __Wire {
237            #[serde(rename = "accessKeyId")]
238            access_key_id: Strict<String>,
239            #[serde(rename = "endpoint")]
240            endpoint: Strict<String>,
241            #[serde(rename = "region")]
242            #[serde(default)]
243            region: Strict<Option<String>>,
244            #[serde(rename = "roleArn")]
245            role_arn: Strict<String>,
246        }
247        let wire = __Wire::deserialize(deserializer)?;
248        Ok(Self {
249            access_key_id: wire.access_key_id.0,
250            endpoint: wire.endpoint.0,
251            region: wire.region.0,
252            role_arn: wire.role_arn.0,
253        })
254    }
255}
256
257/// CephOidc contract value.
258#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
259pub struct CephOidc {
260    /// Contract field endpoint.
261    #[serde(rename = "endpoint")]
262    pub endpoint: String,
263    /// Contract field region.
264    #[serde(rename = "region")]
265    #[serde(default, skip_serializing_if = "Option::is_none")]
266    pub region: Option<String>,
267    /// Contract field roleArn.
268    #[serde(rename = "roleArn")]
269    pub role_arn: String,
270}
271impl<'de> DeserializeStrict<'de> for CephOidc {
272    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
273        #[derive(Deserialize)]
274        #[serde(deny_unknown_fields)]
275        struct __Wire {
276            #[serde(rename = "endpoint")]
277            endpoint: Strict<String>,
278            #[serde(rename = "region")]
279            #[serde(default)]
280            region: Strict<Option<String>>,
281            #[serde(rename = "roleArn")]
282            role_arn: Strict<String>,
283        }
284        let wire = __Wire::deserialize(deserializer)?;
285        Ok(Self {
286            endpoint: wire.endpoint.0,
287            region: wire.region.0,
288            role_arn: wire.role_arn.0,
289        })
290    }
291}
292
293/// CephOidcConfig contract value.
294#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
295pub struct CephOidcConfig {
296    /// Contract field endpoint.
297    #[serde(rename = "endpoint")]
298    pub endpoint: String,
299    /// Contract field region.
300    #[serde(rename = "region")]
301    #[serde(default, skip_serializing_if = "Option::is_none")]
302    pub region: Option<String>,
303    /// Contract field roleArn.
304    #[serde(rename = "roleArn")]
305    pub role_arn: String,
306}
307impl<'de> DeserializeStrict<'de> for CephOidcConfig {
308    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
309        #[derive(Deserialize)]
310        #[serde(deny_unknown_fields)]
311        struct __Wire {
312            #[serde(rename = "endpoint")]
313            endpoint: Strict<String>,
314            #[serde(rename = "region")]
315            #[serde(default)]
316            region: Strict<Option<String>>,
317            #[serde(rename = "roleArn")]
318            role_arn: Strict<String>,
319        }
320        let wire = __Wire::deserialize(deserializer)?;
321        Ok(Self {
322            endpoint: wire.endpoint.0,
323            region: wire.region.0,
324            role_arn: wire.role_arn.0,
325        })
326    }
327}
328
329/// CreateMountRequest contract value.
330#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
331pub struct CreateMountRequest {
332    /// Contract field belongsTo.
333    #[serde(rename = "belongsTo")]
334    #[serde(default, skip_serializing_if = "Option::is_none")]
335    pub belongs_to: Option<String>,
336    /// Contract field directory.
337    #[serde(rename = "directory")]
338    pub directory: String,
339    /// Contract field mode.
340    #[serde(rename = "mode")]
341    pub mode: MountMode,
342    /// Contract field principal.
343    #[serde(rename = "principal")]
344    pub principal: String,
345}
346impl<'de> DeserializeStrict<'de> for CreateMountRequest {
347    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
348        #[derive(Deserialize)]
349        #[serde(deny_unknown_fields)]
350        struct __Wire {
351            #[serde(rename = "belongsTo")]
352            #[serde(default)]
353            belongs_to: Strict<Option<String>>,
354            #[serde(rename = "directory")]
355            directory: Strict<String>,
356            #[serde(rename = "mode")]
357            mode: Strict<MountMode>,
358            #[serde(rename = "principal")]
359            principal: Strict<String>,
360        }
361        let wire = __Wire::deserialize(deserializer)?;
362        Ok(Self {
363            belongs_to: wire.belongs_to.0,
364            directory: wire.directory.0,
365            mode: wire.mode.0,
366            principal: wire.principal.0,
367        })
368    }
369}
370
371/// CreateMountResponse contract value.
372#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
373pub struct CreateMountResponse {
374    /// Contract field mount.
375    #[serde(rename = "mount")]
376    pub mount: Mount,
377}
378impl<'de> DeserializeStrict<'de> for CreateMountResponse {
379    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
380        #[derive(Deserialize)]
381        #[serde(deny_unknown_fields)]
382        struct __Wire {
383            #[serde(rename = "mount")]
384            mount: Strict<Mount>,
385        }
386        let wire = __Wire::deserialize(deserializer)?;
387        Ok(Self {
388            mount: wire.mount.0,
389        })
390    }
391}
392
393/// A complete replacement credential, including every required secret. OIDC credentials contain no
394/// stored secret.
395#[derive(Clone, Debug, PartialEq, Eq)]
396pub enum Credential {
397    /// A known union arm.
398    AwsAccessKey(AwsAccessKey),
399    /// A known union arm.
400    AwsOidc(AwsOidc),
401    /// A known union arm.
402    CephAccessKey(CephAccessKey),
403    /// A known union arm.
404    CephOidc(CephOidc),
405    /// A known union arm.
406    GcsOidc(GcsOidc),
407    /// A known union arm.
408    GcsServiceAccountKey(GcsServiceAccountKey),
409    /// A known union arm.
410    HuggingFaceToken(HuggingFaceCredential),
411    /// A known union arm.
412    MinioAccessKey(S3AccessKey),
413    /// A known union arm.
414    R2AccessKey(R2AccessKey),
415    /// A known union arm.
416    RustfsAccessKey(S3AccessKey),
417    /// A known union arm.
418    S3LikeAccessKey(S3AccessKey),
419    /// An unknown discriminator and its complete wire object.
420    Unknown { tag: String, value: Value },
421}
422impl Serialize for Credential {
423    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
424        match self {
425            Self::AwsAccessKey(value) => {
426                let mut object = serde_json::Map::new();
427                object.insert("type".into(), Value::String("awsAccessKey".into()));
428                object.insert(
429                    "awsAccessKey".into(),
430                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
431                );
432                Value::Object(object).serialize(serializer)
433            }
434            Self::AwsOidc(value) => {
435                let mut object = serde_json::Map::new();
436                object.insert("type".into(), Value::String("awsOidc".into()));
437                object.insert(
438                    "awsOidc".into(),
439                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
440                );
441                Value::Object(object).serialize(serializer)
442            }
443            Self::CephAccessKey(value) => {
444                let mut object = serde_json::Map::new();
445                object.insert("type".into(), Value::String("cephAccessKey".into()));
446                object.insert(
447                    "cephAccessKey".into(),
448                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
449                );
450                Value::Object(object).serialize(serializer)
451            }
452            Self::CephOidc(value) => {
453                let mut object = serde_json::Map::new();
454                object.insert("type".into(), Value::String("cephOidc".into()));
455                object.insert(
456                    "cephOidc".into(),
457                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
458                );
459                Value::Object(object).serialize(serializer)
460            }
461            Self::GcsOidc(value) => {
462                let mut object = serde_json::Map::new();
463                object.insert("type".into(), Value::String("gcsOidc".into()));
464                object.insert(
465                    "gcsOidc".into(),
466                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
467                );
468                Value::Object(object).serialize(serializer)
469            }
470            Self::GcsServiceAccountKey(value) => {
471                let mut object = serde_json::Map::new();
472                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
473                object.insert(
474                    "gcsServiceAccountKey".into(),
475                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
476                );
477                Value::Object(object).serialize(serializer)
478            }
479            Self::HuggingFaceToken(value) => {
480                let mut object = serde_json::Map::new();
481                object.insert("type".into(), Value::String("huggingFaceToken".into()));
482                object.insert(
483                    "huggingFaceToken".into(),
484                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
485                );
486                Value::Object(object).serialize(serializer)
487            }
488            Self::MinioAccessKey(value) => {
489                let mut object = serde_json::Map::new();
490                object.insert("type".into(), Value::String("minioAccessKey".into()));
491                object.insert(
492                    "minioAccessKey".into(),
493                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
494                );
495                Value::Object(object).serialize(serializer)
496            }
497            Self::R2AccessKey(value) => {
498                let mut object = serde_json::Map::new();
499                object.insert("type".into(), Value::String("r2AccessKey".into()));
500                object.insert(
501                    "r2AccessKey".into(),
502                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
503                );
504                Value::Object(object).serialize(serializer)
505            }
506            Self::RustfsAccessKey(value) => {
507                let mut object = serde_json::Map::new();
508                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
509                object.insert(
510                    "rustfsAccessKey".into(),
511                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
512                );
513                Value::Object(object).serialize(serializer)
514            }
515            Self::S3LikeAccessKey(value) => {
516                let mut object = serde_json::Map::new();
517                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
518                object.insert(
519                    "s3LikeAccessKey".into(),
520                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
521                );
522                Value::Object(object).serialize(serializer)
523            }
524            Self::Unknown { tag, value } => {
525                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
526                    return Err(serde::ser::Error::custom(
527                        "unknown union discriminator mismatch",
528                    ));
529                }
530                value.serialize(serializer)
531            }
532        }
533    }
534}
535impl<'de> Deserialize<'de> for Credential {
536    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
537        let value = Value::deserialize(deserializer)?;
538        let tag = value
539            .get("type")
540            .and_then(Value::as_str)
541            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
542        match tag {
543            "awsAccessKey" => Ok(Self::AwsAccessKey(
544                serde_json::from_value(
545                    value
546                        .get("awsAccessKey")
547                        .cloned()
548                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
549                )
550                .map_err(serde::de::Error::custom)?,
551            )),
552            "awsOidc" => Ok(Self::AwsOidc(
553                serde_json::from_value(
554                    value
555                        .get("awsOidc")
556                        .cloned()
557                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
558                )
559                .map_err(serde::de::Error::custom)?,
560            )),
561            "cephAccessKey" => Ok(Self::CephAccessKey(
562                serde_json::from_value(
563                    value
564                        .get("cephAccessKey")
565                        .cloned()
566                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
567                )
568                .map_err(serde::de::Error::custom)?,
569            )),
570            "cephOidc" => Ok(Self::CephOidc(
571                serde_json::from_value(
572                    value
573                        .get("cephOidc")
574                        .cloned()
575                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
576                )
577                .map_err(serde::de::Error::custom)?,
578            )),
579            "gcsOidc" => Ok(Self::GcsOidc(
580                serde_json::from_value(
581                    value
582                        .get("gcsOidc")
583                        .cloned()
584                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
585                )
586                .map_err(serde::de::Error::custom)?,
587            )),
588            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
589                serde_json::from_value(
590                    value
591                        .get("gcsServiceAccountKey")
592                        .cloned()
593                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
594                )
595                .map_err(serde::de::Error::custom)?,
596            )),
597            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
598                serde_json::from_value(
599                    value
600                        .get("huggingFaceToken")
601                        .cloned()
602                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
603                )
604                .map_err(serde::de::Error::custom)?,
605            )),
606            "minioAccessKey" => Ok(Self::MinioAccessKey(
607                serde_json::from_value(
608                    value
609                        .get("minioAccessKey")
610                        .cloned()
611                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
612                )
613                .map_err(serde::de::Error::custom)?,
614            )),
615            "r2AccessKey" => Ok(Self::R2AccessKey(
616                serde_json::from_value(
617                    value
618                        .get("r2AccessKey")
619                        .cloned()
620                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
621                )
622                .map_err(serde::de::Error::custom)?,
623            )),
624            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
625                serde_json::from_value(
626                    value
627                        .get("rustfsAccessKey")
628                        .cloned()
629                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
630                )
631                .map_err(serde::de::Error::custom)?,
632            )),
633            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
634                serde_json::from_value(
635                    value
636                        .get("s3LikeAccessKey")
637                        .cloned()
638                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
639                )
640                .map_err(serde::de::Error::custom)?,
641            )),
642            tag => Ok(Self::Unknown {
643                tag: tag.to_owned(),
644                value,
645            }),
646        }
647    }
648}
649impl<'de> DeserializeStrict<'de> for Credential {
650    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
651        #[derive(Deserialize)]
652        enum __Tag0 {
653            #[serde(rename = "awsAccessKey")]
654            Value,
655        }
656        #[derive(Deserialize)]
657        #[serde(deny_unknown_fields)]
658        struct __Arm0 {
659            #[serde(rename = "type")]
660            _tag: __Tag0,
661            #[serde(rename = "awsAccessKey")]
662            value: Strict<AwsAccessKey>,
663        }
664        #[derive(Deserialize)]
665        enum __Tag1 {
666            #[serde(rename = "awsOidc")]
667            Value,
668        }
669        #[derive(Deserialize)]
670        #[serde(deny_unknown_fields)]
671        struct __Arm1 {
672            #[serde(rename = "type")]
673            _tag: __Tag1,
674            #[serde(rename = "awsOidc")]
675            value: Strict<AwsOidc>,
676        }
677        #[derive(Deserialize)]
678        enum __Tag2 {
679            #[serde(rename = "cephAccessKey")]
680            Value,
681        }
682        #[derive(Deserialize)]
683        #[serde(deny_unknown_fields)]
684        struct __Arm2 {
685            #[serde(rename = "type")]
686            _tag: __Tag2,
687            #[serde(rename = "cephAccessKey")]
688            value: Strict<CephAccessKey>,
689        }
690        #[derive(Deserialize)]
691        enum __Tag3 {
692            #[serde(rename = "cephOidc")]
693            Value,
694        }
695        #[derive(Deserialize)]
696        #[serde(deny_unknown_fields)]
697        struct __Arm3 {
698            #[serde(rename = "type")]
699            _tag: __Tag3,
700            #[serde(rename = "cephOidc")]
701            value: Strict<CephOidc>,
702        }
703        #[derive(Deserialize)]
704        enum __Tag4 {
705            #[serde(rename = "gcsOidc")]
706            Value,
707        }
708        #[derive(Deserialize)]
709        #[serde(deny_unknown_fields)]
710        struct __Arm4 {
711            #[serde(rename = "type")]
712            _tag: __Tag4,
713            #[serde(rename = "gcsOidc")]
714            value: Strict<GcsOidc>,
715        }
716        #[derive(Deserialize)]
717        enum __Tag5 {
718            #[serde(rename = "gcsServiceAccountKey")]
719            Value,
720        }
721        #[derive(Deserialize)]
722        #[serde(deny_unknown_fields)]
723        struct __Arm5 {
724            #[serde(rename = "type")]
725            _tag: __Tag5,
726            #[serde(rename = "gcsServiceAccountKey")]
727            value: Strict<GcsServiceAccountKey>,
728        }
729        #[derive(Deserialize)]
730        enum __Tag6 {
731            #[serde(rename = "huggingFaceToken")]
732            Value,
733        }
734        #[derive(Deserialize)]
735        #[serde(deny_unknown_fields)]
736        struct __Arm6 {
737            #[serde(rename = "type")]
738            _tag: __Tag6,
739            #[serde(rename = "huggingFaceToken")]
740            value: Strict<HuggingFaceCredential>,
741        }
742        #[derive(Deserialize)]
743        enum __Tag7 {
744            #[serde(rename = "minioAccessKey")]
745            Value,
746        }
747        #[derive(Deserialize)]
748        #[serde(deny_unknown_fields)]
749        struct __Arm7 {
750            #[serde(rename = "type")]
751            _tag: __Tag7,
752            #[serde(rename = "minioAccessKey")]
753            value: Strict<S3AccessKey>,
754        }
755        #[derive(Deserialize)]
756        enum __Tag8 {
757            #[serde(rename = "r2AccessKey")]
758            Value,
759        }
760        #[derive(Deserialize)]
761        #[serde(deny_unknown_fields)]
762        struct __Arm8 {
763            #[serde(rename = "type")]
764            _tag: __Tag8,
765            #[serde(rename = "r2AccessKey")]
766            value: Strict<R2AccessKey>,
767        }
768        #[derive(Deserialize)]
769        enum __Tag9 {
770            #[serde(rename = "rustfsAccessKey")]
771            Value,
772        }
773        #[derive(Deserialize)]
774        #[serde(deny_unknown_fields)]
775        struct __Arm9 {
776            #[serde(rename = "type")]
777            _tag: __Tag9,
778            #[serde(rename = "rustfsAccessKey")]
779            value: Strict<S3AccessKey>,
780        }
781        #[derive(Deserialize)]
782        enum __Tag10 {
783            #[serde(rename = "s3LikeAccessKey")]
784            Value,
785        }
786        #[derive(Deserialize)]
787        #[serde(deny_unknown_fields)]
788        struct __Arm10 {
789            #[serde(rename = "type")]
790            _tag: __Tag10,
791            #[serde(rename = "s3LikeAccessKey")]
792            value: Strict<S3AccessKey>,
793        }
794        #[derive(Deserialize)]
795        #[serde(untagged)]
796        enum __Known {
797            AwsAccessKey(Box<__Arm0>),
798            AwsOidc(Box<__Arm1>),
799            CephAccessKey(Box<__Arm2>),
800            CephOidc(Box<__Arm3>),
801            GcsOidc(Box<__Arm4>),
802            GcsServiceAccountKey(Box<__Arm5>),
803            HuggingFaceToken(Box<__Arm6>),
804            MinioAccessKey(Box<__Arm7>),
805            R2AccessKey(Box<__Arm8>),
806            RustfsAccessKey(Box<__Arm9>),
807            S3LikeAccessKey(Box<__Arm10>),
808        }
809        Ok(match __Known::deserialize(deserializer)? {
810            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
811            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
812            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
813            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
814            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
815            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
816            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
817            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
818            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
819            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
820            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
821        })
822    }
823}
824
825/// The credential configuration returned by reads. It has no fields for stored secrets.
826#[derive(Clone, Debug, PartialEq, Eq)]
827pub enum CredentialConfig {
828    /// A known union arm.
829    AwsAccessKey(AwsAccessKeyConfig),
830    /// A known union arm.
831    AwsOidc(AwsOidcConfig),
832    /// A known union arm.
833    CephAccessKey(CephAccessKeyConfig),
834    /// A known union arm.
835    CephOidc(CephOidcConfig),
836    /// A known union arm.
837    GcsOidc(GcsOidcConfig),
838    /// A known union arm.
839    GcsServiceAccountKey(GcsServiceAccountKeyConfig),
840    /// A known union arm.
841    HuggingFaceToken(HuggingFaceCredentialConfig),
842    /// A known union arm.
843    MinioAccessKey(S3AccessKeyConfig),
844    /// A known union arm.
845    R2AccessKey(R2AccessKeyConfig),
846    /// A known union arm.
847    RustfsAccessKey(S3AccessKeyConfig),
848    /// A known union arm.
849    S3LikeAccessKey(S3AccessKeyConfig),
850    /// An unknown discriminator and its complete wire object.
851    Unknown { tag: String, value: Value },
852}
853impl Serialize for CredentialConfig {
854    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
855        match self {
856            Self::AwsAccessKey(value) => {
857                let mut object = serde_json::Map::new();
858                object.insert("type".into(), Value::String("awsAccessKey".into()));
859                object.insert(
860                    "awsAccessKey".into(),
861                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
862                );
863                Value::Object(object).serialize(serializer)
864            }
865            Self::AwsOidc(value) => {
866                let mut object = serde_json::Map::new();
867                object.insert("type".into(), Value::String("awsOidc".into()));
868                object.insert(
869                    "awsOidc".into(),
870                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
871                );
872                Value::Object(object).serialize(serializer)
873            }
874            Self::CephAccessKey(value) => {
875                let mut object = serde_json::Map::new();
876                object.insert("type".into(), Value::String("cephAccessKey".into()));
877                object.insert(
878                    "cephAccessKey".into(),
879                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
880                );
881                Value::Object(object).serialize(serializer)
882            }
883            Self::CephOidc(value) => {
884                let mut object = serde_json::Map::new();
885                object.insert("type".into(), Value::String("cephOidc".into()));
886                object.insert(
887                    "cephOidc".into(),
888                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
889                );
890                Value::Object(object).serialize(serializer)
891            }
892            Self::GcsOidc(value) => {
893                let mut object = serde_json::Map::new();
894                object.insert("type".into(), Value::String("gcsOidc".into()));
895                object.insert(
896                    "gcsOidc".into(),
897                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
898                );
899                Value::Object(object).serialize(serializer)
900            }
901            Self::GcsServiceAccountKey(value) => {
902                let mut object = serde_json::Map::new();
903                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
904                object.insert(
905                    "gcsServiceAccountKey".into(),
906                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
907                );
908                Value::Object(object).serialize(serializer)
909            }
910            Self::HuggingFaceToken(value) => {
911                let mut object = serde_json::Map::new();
912                object.insert("type".into(), Value::String("huggingFaceToken".into()));
913                object.insert(
914                    "huggingFaceToken".into(),
915                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
916                );
917                Value::Object(object).serialize(serializer)
918            }
919            Self::MinioAccessKey(value) => {
920                let mut object = serde_json::Map::new();
921                object.insert("type".into(), Value::String("minioAccessKey".into()));
922                object.insert(
923                    "minioAccessKey".into(),
924                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
925                );
926                Value::Object(object).serialize(serializer)
927            }
928            Self::R2AccessKey(value) => {
929                let mut object = serde_json::Map::new();
930                object.insert("type".into(), Value::String("r2AccessKey".into()));
931                object.insert(
932                    "r2AccessKey".into(),
933                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
934                );
935                Value::Object(object).serialize(serializer)
936            }
937            Self::RustfsAccessKey(value) => {
938                let mut object = serde_json::Map::new();
939                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
940                object.insert(
941                    "rustfsAccessKey".into(),
942                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
943                );
944                Value::Object(object).serialize(serializer)
945            }
946            Self::S3LikeAccessKey(value) => {
947                let mut object = serde_json::Map::new();
948                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
949                object.insert(
950                    "s3LikeAccessKey".into(),
951                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
952                );
953                Value::Object(object).serialize(serializer)
954            }
955            Self::Unknown { tag, value } => {
956                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
957                    return Err(serde::ser::Error::custom(
958                        "unknown union discriminator mismatch",
959                    ));
960                }
961                value.serialize(serializer)
962            }
963        }
964    }
965}
966impl<'de> Deserialize<'de> for CredentialConfig {
967    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
968        let value = Value::deserialize(deserializer)?;
969        let tag = value
970            .get("type")
971            .and_then(Value::as_str)
972            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
973        match tag {
974            "awsAccessKey" => Ok(Self::AwsAccessKey(
975                serde_json::from_value(
976                    value
977                        .get("awsAccessKey")
978                        .cloned()
979                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
980                )
981                .map_err(serde::de::Error::custom)?,
982            )),
983            "awsOidc" => Ok(Self::AwsOidc(
984                serde_json::from_value(
985                    value
986                        .get("awsOidc")
987                        .cloned()
988                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
989                )
990                .map_err(serde::de::Error::custom)?,
991            )),
992            "cephAccessKey" => Ok(Self::CephAccessKey(
993                serde_json::from_value(
994                    value
995                        .get("cephAccessKey")
996                        .cloned()
997                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
998                )
999                .map_err(serde::de::Error::custom)?,
1000            )),
1001            "cephOidc" => Ok(Self::CephOidc(
1002                serde_json::from_value(
1003                    value
1004                        .get("cephOidc")
1005                        .cloned()
1006                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1007                )
1008                .map_err(serde::de::Error::custom)?,
1009            )),
1010            "gcsOidc" => Ok(Self::GcsOidc(
1011                serde_json::from_value(
1012                    value
1013                        .get("gcsOidc")
1014                        .cloned()
1015                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1016                )
1017                .map_err(serde::de::Error::custom)?,
1018            )),
1019            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
1020                serde_json::from_value(
1021                    value
1022                        .get("gcsServiceAccountKey")
1023                        .cloned()
1024                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1025                )
1026                .map_err(serde::de::Error::custom)?,
1027            )),
1028            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
1029                serde_json::from_value(
1030                    value
1031                        .get("huggingFaceToken")
1032                        .cloned()
1033                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1034                )
1035                .map_err(serde::de::Error::custom)?,
1036            )),
1037            "minioAccessKey" => Ok(Self::MinioAccessKey(
1038                serde_json::from_value(
1039                    value
1040                        .get("minioAccessKey")
1041                        .cloned()
1042                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1043                )
1044                .map_err(serde::de::Error::custom)?,
1045            )),
1046            "r2AccessKey" => Ok(Self::R2AccessKey(
1047                serde_json::from_value(
1048                    value
1049                        .get("r2AccessKey")
1050                        .cloned()
1051                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1052                )
1053                .map_err(serde::de::Error::custom)?,
1054            )),
1055            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
1056                serde_json::from_value(
1057                    value
1058                        .get("rustfsAccessKey")
1059                        .cloned()
1060                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1061                )
1062                .map_err(serde::de::Error::custom)?,
1063            )),
1064            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
1065                serde_json::from_value(
1066                    value
1067                        .get("s3LikeAccessKey")
1068                        .cloned()
1069                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1070                )
1071                .map_err(serde::de::Error::custom)?,
1072            )),
1073            tag => Ok(Self::Unknown {
1074                tag: tag.to_owned(),
1075                value,
1076            }),
1077        }
1078    }
1079}
1080impl<'de> DeserializeStrict<'de> for CredentialConfig {
1081    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1082        #[derive(Deserialize)]
1083        enum __Tag0 {
1084            #[serde(rename = "awsAccessKey")]
1085            Value,
1086        }
1087        #[derive(Deserialize)]
1088        #[serde(deny_unknown_fields)]
1089        struct __Arm0 {
1090            #[serde(rename = "type")]
1091            _tag: __Tag0,
1092            #[serde(rename = "awsAccessKey")]
1093            value: Strict<AwsAccessKeyConfig>,
1094        }
1095        #[derive(Deserialize)]
1096        enum __Tag1 {
1097            #[serde(rename = "awsOidc")]
1098            Value,
1099        }
1100        #[derive(Deserialize)]
1101        #[serde(deny_unknown_fields)]
1102        struct __Arm1 {
1103            #[serde(rename = "type")]
1104            _tag: __Tag1,
1105            #[serde(rename = "awsOidc")]
1106            value: Strict<AwsOidcConfig>,
1107        }
1108        #[derive(Deserialize)]
1109        enum __Tag2 {
1110            #[serde(rename = "cephAccessKey")]
1111            Value,
1112        }
1113        #[derive(Deserialize)]
1114        #[serde(deny_unknown_fields)]
1115        struct __Arm2 {
1116            #[serde(rename = "type")]
1117            _tag: __Tag2,
1118            #[serde(rename = "cephAccessKey")]
1119            value: Strict<CephAccessKeyConfig>,
1120        }
1121        #[derive(Deserialize)]
1122        enum __Tag3 {
1123            #[serde(rename = "cephOidc")]
1124            Value,
1125        }
1126        #[derive(Deserialize)]
1127        #[serde(deny_unknown_fields)]
1128        struct __Arm3 {
1129            #[serde(rename = "type")]
1130            _tag: __Tag3,
1131            #[serde(rename = "cephOidc")]
1132            value: Strict<CephOidcConfig>,
1133        }
1134        #[derive(Deserialize)]
1135        enum __Tag4 {
1136            #[serde(rename = "gcsOidc")]
1137            Value,
1138        }
1139        #[derive(Deserialize)]
1140        #[serde(deny_unknown_fields)]
1141        struct __Arm4 {
1142            #[serde(rename = "type")]
1143            _tag: __Tag4,
1144            #[serde(rename = "gcsOidc")]
1145            value: Strict<GcsOidcConfig>,
1146        }
1147        #[derive(Deserialize)]
1148        enum __Tag5 {
1149            #[serde(rename = "gcsServiceAccountKey")]
1150            Value,
1151        }
1152        #[derive(Deserialize)]
1153        #[serde(deny_unknown_fields)]
1154        struct __Arm5 {
1155            #[serde(rename = "type")]
1156            _tag: __Tag5,
1157            #[serde(rename = "gcsServiceAccountKey")]
1158            value: Strict<GcsServiceAccountKeyConfig>,
1159        }
1160        #[derive(Deserialize)]
1161        enum __Tag6 {
1162            #[serde(rename = "huggingFaceToken")]
1163            Value,
1164        }
1165        #[derive(Deserialize)]
1166        #[serde(deny_unknown_fields)]
1167        struct __Arm6 {
1168            #[serde(rename = "type")]
1169            _tag: __Tag6,
1170            #[serde(rename = "huggingFaceToken")]
1171            value: Strict<HuggingFaceCredentialConfig>,
1172        }
1173        #[derive(Deserialize)]
1174        enum __Tag7 {
1175            #[serde(rename = "minioAccessKey")]
1176            Value,
1177        }
1178        #[derive(Deserialize)]
1179        #[serde(deny_unknown_fields)]
1180        struct __Arm7 {
1181            #[serde(rename = "type")]
1182            _tag: __Tag7,
1183            #[serde(rename = "minioAccessKey")]
1184            value: Strict<S3AccessKeyConfig>,
1185        }
1186        #[derive(Deserialize)]
1187        enum __Tag8 {
1188            #[serde(rename = "r2AccessKey")]
1189            Value,
1190        }
1191        #[derive(Deserialize)]
1192        #[serde(deny_unknown_fields)]
1193        struct __Arm8 {
1194            #[serde(rename = "type")]
1195            _tag: __Tag8,
1196            #[serde(rename = "r2AccessKey")]
1197            value: Strict<R2AccessKeyConfig>,
1198        }
1199        #[derive(Deserialize)]
1200        enum __Tag9 {
1201            #[serde(rename = "rustfsAccessKey")]
1202            Value,
1203        }
1204        #[derive(Deserialize)]
1205        #[serde(deny_unknown_fields)]
1206        struct __Arm9 {
1207            #[serde(rename = "type")]
1208            _tag: __Tag9,
1209            #[serde(rename = "rustfsAccessKey")]
1210            value: Strict<S3AccessKeyConfig>,
1211        }
1212        #[derive(Deserialize)]
1213        enum __Tag10 {
1214            #[serde(rename = "s3LikeAccessKey")]
1215            Value,
1216        }
1217        #[derive(Deserialize)]
1218        #[serde(deny_unknown_fields)]
1219        struct __Arm10 {
1220            #[serde(rename = "type")]
1221            _tag: __Tag10,
1222            #[serde(rename = "s3LikeAccessKey")]
1223            value: Strict<S3AccessKeyConfig>,
1224        }
1225        #[derive(Deserialize)]
1226        #[serde(untagged)]
1227        enum __Known {
1228            AwsAccessKey(Box<__Arm0>),
1229            AwsOidc(Box<__Arm1>),
1230            CephAccessKey(Box<__Arm2>),
1231            CephOidc(Box<__Arm3>),
1232            GcsOidc(Box<__Arm4>),
1233            GcsServiceAccountKey(Box<__Arm5>),
1234            HuggingFaceToken(Box<__Arm6>),
1235            MinioAccessKey(Box<__Arm7>),
1236            R2AccessKey(Box<__Arm8>),
1237            RustfsAccessKey(Box<__Arm9>),
1238            S3LikeAccessKey(Box<__Arm10>),
1239        }
1240        Ok(match __Known::deserialize(deserializer)? {
1241            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
1242            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
1243            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
1244            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
1245            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
1246            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
1247            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
1248            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
1249            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
1250            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
1251            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
1252        })
1253    }
1254}
1255
1256/// FileSystem contract value.
1257#[derive(Clone, Debug, PartialEq, Eq)]
1258pub enum FileSystem {
1259    /// A known union arm.
1260    Builtin(BuiltinFileSystem),
1261    /// A known union arm.
1262    Gcs(GcsFileSystem),
1263    /// A known union arm.
1264    R2(R2FileSystem),
1265    /// A known union arm.
1266    S3(S3FileSystem),
1267    /// A known union arm.
1268    S3Like(S3LikeFileSystem),
1269    /// A known union arm.
1270    Upstream(UpstreamFileSystem),
1271    /// An unknown discriminator and its complete wire object.
1272    Unknown { tag: String, value: Value },
1273}
1274impl Serialize for FileSystem {
1275    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1276        match self {
1277            Self::Builtin(value) => {
1278                let mut object = serde_json::Map::new();
1279                object.insert("type".into(), Value::String("builtin".into()));
1280                object.insert(
1281                    "builtin".into(),
1282                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1283                );
1284                Value::Object(object).serialize(serializer)
1285            }
1286            Self::Gcs(value) => {
1287                let mut object = serde_json::Map::new();
1288                object.insert("type".into(), Value::String("gcs".into()));
1289                object.insert(
1290                    "gcs".into(),
1291                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1292                );
1293                Value::Object(object).serialize(serializer)
1294            }
1295            Self::R2(value) => {
1296                let mut object = serde_json::Map::new();
1297                object.insert("type".into(), Value::String("r2".into()));
1298                object.insert(
1299                    "r2".into(),
1300                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1301                );
1302                Value::Object(object).serialize(serializer)
1303            }
1304            Self::S3(value) => {
1305                let mut object = serde_json::Map::new();
1306                object.insert("type".into(), Value::String("s3".into()));
1307                object.insert(
1308                    "s3".into(),
1309                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1310                );
1311                Value::Object(object).serialize(serializer)
1312            }
1313            Self::S3Like(value) => {
1314                let mut object = serde_json::Map::new();
1315                object.insert("type".into(), Value::String("s3Like".into()));
1316                object.insert(
1317                    "s3Like".into(),
1318                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1319                );
1320                Value::Object(object).serialize(serializer)
1321            }
1322            Self::Upstream(value) => {
1323                let mut object = serde_json::Map::new();
1324                object.insert("type".into(), Value::String("upstream".into()));
1325                object.insert(
1326                    "upstream".into(),
1327                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1328                );
1329                Value::Object(object).serialize(serializer)
1330            }
1331            Self::Unknown { tag, value } => {
1332                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
1333                    return Err(serde::ser::Error::custom(
1334                        "unknown union discriminator mismatch",
1335                    ));
1336                }
1337                value.serialize(serializer)
1338            }
1339        }
1340    }
1341}
1342impl<'de> Deserialize<'de> for FileSystem {
1343    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1344        let value = Value::deserialize(deserializer)?;
1345        let tag = value
1346            .get("type")
1347            .and_then(Value::as_str)
1348            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
1349        match tag {
1350            "builtin" => Ok(Self::Builtin(
1351                serde_json::from_value(
1352                    value
1353                        .get("builtin")
1354                        .cloned()
1355                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1356                )
1357                .map_err(serde::de::Error::custom)?,
1358            )),
1359            "gcs" => Ok(Self::Gcs(
1360                serde_json::from_value(
1361                    value
1362                        .get("gcs")
1363                        .cloned()
1364                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1365                )
1366                .map_err(serde::de::Error::custom)?,
1367            )),
1368            "r2" => Ok(Self::R2(
1369                serde_json::from_value(
1370                    value
1371                        .get("r2")
1372                        .cloned()
1373                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1374                )
1375                .map_err(serde::de::Error::custom)?,
1376            )),
1377            "s3" => Ok(Self::S3(
1378                serde_json::from_value(
1379                    value
1380                        .get("s3")
1381                        .cloned()
1382                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1383                )
1384                .map_err(serde::de::Error::custom)?,
1385            )),
1386            "s3Like" => Ok(Self::S3Like(
1387                serde_json::from_value(
1388                    value
1389                        .get("s3Like")
1390                        .cloned()
1391                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1392                )
1393                .map_err(serde::de::Error::custom)?,
1394            )),
1395            "upstream" => Ok(Self::Upstream(
1396                serde_json::from_value(
1397                    value
1398                        .get("upstream")
1399                        .cloned()
1400                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1401                )
1402                .map_err(serde::de::Error::custom)?,
1403            )),
1404            tag => Ok(Self::Unknown {
1405                tag: tag.to_owned(),
1406                value,
1407            }),
1408        }
1409    }
1410}
1411impl<'de> DeserializeStrict<'de> for FileSystem {
1412    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1413        #[derive(Deserialize)]
1414        enum __Tag0 {
1415            #[serde(rename = "builtin")]
1416            Value,
1417        }
1418        #[derive(Deserialize)]
1419        #[serde(deny_unknown_fields)]
1420        struct __Arm0 {
1421            #[serde(rename = "type")]
1422            _tag: __Tag0,
1423            #[serde(rename = "builtin")]
1424            value: Strict<BuiltinFileSystem>,
1425        }
1426        #[derive(Deserialize)]
1427        enum __Tag1 {
1428            #[serde(rename = "gcs")]
1429            Value,
1430        }
1431        #[derive(Deserialize)]
1432        #[serde(deny_unknown_fields)]
1433        struct __Arm1 {
1434            #[serde(rename = "type")]
1435            _tag: __Tag1,
1436            #[serde(rename = "gcs")]
1437            value: Strict<GcsFileSystem>,
1438        }
1439        #[derive(Deserialize)]
1440        enum __Tag2 {
1441            #[serde(rename = "r2")]
1442            Value,
1443        }
1444        #[derive(Deserialize)]
1445        #[serde(deny_unknown_fields)]
1446        struct __Arm2 {
1447            #[serde(rename = "type")]
1448            _tag: __Tag2,
1449            #[serde(rename = "r2")]
1450            value: Strict<R2FileSystem>,
1451        }
1452        #[derive(Deserialize)]
1453        enum __Tag3 {
1454            #[serde(rename = "s3")]
1455            Value,
1456        }
1457        #[derive(Deserialize)]
1458        #[serde(deny_unknown_fields)]
1459        struct __Arm3 {
1460            #[serde(rename = "type")]
1461            _tag: __Tag3,
1462            #[serde(rename = "s3")]
1463            value: Strict<S3FileSystem>,
1464        }
1465        #[derive(Deserialize)]
1466        enum __Tag4 {
1467            #[serde(rename = "s3Like")]
1468            Value,
1469        }
1470        #[derive(Deserialize)]
1471        #[serde(deny_unknown_fields)]
1472        struct __Arm4 {
1473            #[serde(rename = "type")]
1474            _tag: __Tag4,
1475            #[serde(rename = "s3Like")]
1476            value: Strict<S3LikeFileSystem>,
1477        }
1478        #[derive(Deserialize)]
1479        enum __Tag5 {
1480            #[serde(rename = "upstream")]
1481            Value,
1482        }
1483        #[derive(Deserialize)]
1484        #[serde(deny_unknown_fields)]
1485        struct __Arm5 {
1486            #[serde(rename = "type")]
1487            _tag: __Tag5,
1488            #[serde(rename = "upstream")]
1489            value: Strict<UpstreamFileSystem>,
1490        }
1491        #[derive(Deserialize)]
1492        #[serde(untagged)]
1493        enum __Known {
1494            Builtin(Box<__Arm0>),
1495            Gcs(Box<__Arm1>),
1496            R2(Box<__Arm2>),
1497            S3(Box<__Arm3>),
1498            S3Like(Box<__Arm4>),
1499            Upstream(Box<__Arm5>),
1500        }
1501        Ok(match __Known::deserialize(deserializer)? {
1502            __Known::Builtin(arm) => Self::Builtin(arm.value.0),
1503            __Known::Gcs(arm) => Self::Gcs(arm.value.0),
1504            __Known::R2(arm) => Self::R2(arm.value.0),
1505            __Known::S3(arm) => Self::S3(arm.value.0),
1506            __Known::S3Like(arm) => Self::S3Like(arm.value.0),
1507            __Known::Upstream(arm) => Self::Upstream(arm.value.0),
1508        })
1509    }
1510}
1511
1512/// FileSystemWithId contract value.
1513#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1514pub struct FileSystemWithId {
1515    /// Contract field fileSystem.
1516    #[serde(rename = "fileSystem")]
1517    pub file_system: FileSystem,
1518    /// Contract field id.
1519    #[serde(rename = "id")]
1520    pub id: String,
1521}
1522impl<'de> DeserializeStrict<'de> for FileSystemWithId {
1523    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1524        #[derive(Deserialize)]
1525        #[serde(deny_unknown_fields)]
1526        struct __Wire {
1527            #[serde(rename = "fileSystem")]
1528            file_system: Strict<FileSystem>,
1529            #[serde(rename = "id")]
1530            id: Strict<String>,
1531        }
1532        let wire = __Wire::deserialize(deserializer)?;
1533        Ok(Self {
1534            file_system: wire.file_system.0,
1535            id: wire.id.0,
1536        })
1537    }
1538}
1539
1540/// GcsFileSystem contract value.
1541#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1542pub struct GcsFileSystem {
1543    /// Contract field bucket.
1544    #[serde(rename = "bucket")]
1545    pub bucket: String,
1546    /// Contract field directory.
1547    #[serde(rename = "directory")]
1548    pub directory: String,
1549    /// Contract field region.
1550    #[serde(rename = "region")]
1551    pub region: String,
1552}
1553impl<'de> DeserializeStrict<'de> for GcsFileSystem {
1554    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1555        #[derive(Deserialize)]
1556        #[serde(deny_unknown_fields)]
1557        struct __Wire {
1558            #[serde(rename = "bucket")]
1559            bucket: Strict<String>,
1560            #[serde(rename = "directory")]
1561            directory: Strict<String>,
1562            #[serde(rename = "region")]
1563            region: Strict<String>,
1564        }
1565        let wire = __Wire::deserialize(deserializer)?;
1566        Ok(Self {
1567            bucket: wire.bucket.0,
1568            directory: wire.directory.0,
1569            region: wire.region.0,
1570        })
1571    }
1572}
1573
1574/// GcsOidc contract value.
1575#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1576pub struct GcsOidc {
1577    /// Contract field serviceAccount.
1578    #[serde(rename = "serviceAccount")]
1579    pub service_account: String,
1580    /// Contract field workloadIdentityProvider.
1581    #[serde(rename = "workloadIdentityProvider")]
1582    pub workload_identity_provider: String,
1583}
1584impl<'de> DeserializeStrict<'de> for GcsOidc {
1585    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1586        #[derive(Deserialize)]
1587        #[serde(deny_unknown_fields)]
1588        struct __Wire {
1589            #[serde(rename = "serviceAccount")]
1590            service_account: Strict<String>,
1591            #[serde(rename = "workloadIdentityProvider")]
1592            workload_identity_provider: Strict<String>,
1593        }
1594        let wire = __Wire::deserialize(deserializer)?;
1595        Ok(Self {
1596            service_account: wire.service_account.0,
1597            workload_identity_provider: wire.workload_identity_provider.0,
1598        })
1599    }
1600}
1601
1602/// GcsOidcConfig contract value.
1603#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1604pub struct GcsOidcConfig {
1605    /// Contract field serviceAccount.
1606    #[serde(rename = "serviceAccount")]
1607    pub service_account: String,
1608    /// Contract field workloadIdentityProvider.
1609    #[serde(rename = "workloadIdentityProvider")]
1610    pub workload_identity_provider: String,
1611}
1612impl<'de> DeserializeStrict<'de> for GcsOidcConfig {
1613    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1614        #[derive(Deserialize)]
1615        #[serde(deny_unknown_fields)]
1616        struct __Wire {
1617            #[serde(rename = "serviceAccount")]
1618            service_account: Strict<String>,
1619            #[serde(rename = "workloadIdentityProvider")]
1620            workload_identity_provider: Strict<String>,
1621        }
1622        let wire = __Wire::deserialize(deserializer)?;
1623        Ok(Self {
1624            service_account: wire.service_account.0,
1625            workload_identity_provider: wire.workload_identity_provider.0,
1626        })
1627    }
1628}
1629
1630/// GcsServiceAccountKey contract value.
1631#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1632pub struct GcsServiceAccountKey {
1633    /// Contract field keyJson.
1634    #[serde(rename = "keyJson")]
1635    pub key_json: SecretToken,
1636}
1637impl<'de> DeserializeStrict<'de> for GcsServiceAccountKey {
1638    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1639        #[derive(Deserialize)]
1640        #[serde(deny_unknown_fields)]
1641        struct __Wire {
1642            #[serde(rename = "keyJson")]
1643            key_json: Strict<SecretToken>,
1644        }
1645        let wire = __Wire::deserialize(deserializer)?;
1646        Ok(Self {
1647            key_json: wire.key_json.0,
1648        })
1649    }
1650}
1651
1652/// GcsServiceAccountKeyConfig contract value.
1653#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1654pub struct GcsServiceAccountKeyConfig {
1655    /// Contract field privateKeyId.
1656    #[serde(rename = "privateKeyId")]
1657    pub private_key_id: String,
1658    /// Contract field serviceAccount.
1659    #[serde(rename = "serviceAccount")]
1660    pub service_account: String,
1661}
1662impl<'de> DeserializeStrict<'de> for GcsServiceAccountKeyConfig {
1663    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1664        #[derive(Deserialize)]
1665        #[serde(deny_unknown_fields)]
1666        struct __Wire {
1667            #[serde(rename = "privateKeyId")]
1668            private_key_id: Strict<String>,
1669            #[serde(rename = "serviceAccount")]
1670            service_account: Strict<String>,
1671        }
1672        let wire = __Wire::deserialize(deserializer)?;
1673        Ok(Self {
1674            private_key_id: wire.private_key_id.0,
1675            service_account: wire.service_account.0,
1676        })
1677    }
1678}
1679
1680/// GetMountAndFileSystemResponse contract value.
1681#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1682pub struct GetMountAndFileSystemResponse {
1683    /// Contract field fileSystem.
1684    #[serde(rename = "fileSystem")]
1685    pub file_system: FileSystemWithId,
1686    /// Contract field fsLoc.
1687    #[serde(rename = "fsLoc")]
1688    pub fs_loc: String,
1689    /// Contract field mount.
1690    #[serde(rename = "mount")]
1691    pub mount: Mount,
1692}
1693impl<'de> DeserializeStrict<'de> for GetMountAndFileSystemResponse {
1694    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1695        #[derive(Deserialize)]
1696        #[serde(deny_unknown_fields)]
1697        struct __Wire {
1698            #[serde(rename = "fileSystem")]
1699            file_system: Strict<FileSystemWithId>,
1700            #[serde(rename = "fsLoc")]
1701            fs_loc: Strict<String>,
1702            #[serde(rename = "mount")]
1703            mount: Strict<Mount>,
1704        }
1705        let wire = __Wire::deserialize(deserializer)?;
1706        Ok(Self {
1707            file_system: wire.file_system.0,
1708            fs_loc: wire.fs_loc.0,
1709            mount: wire.mount.0,
1710        })
1711    }
1712}
1713
1714/// GlobalMountsRequest contract value.
1715#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1716pub struct GlobalMountsRequest {
1717    /// Contract field fsLoc.
1718    #[serde(rename = "fsLoc")]
1719    pub fs_loc: String,
1720    /// Contract field pageSize.
1721    #[serde(rename = "pageSize")]
1722    #[serde(default, skip_serializing_if = "Option::is_none")]
1723    pub page_size: Option<u32>,
1724    /// Contract field pageToken.
1725    #[serde(rename = "pageToken")]
1726    #[serde(default, skip_serializing_if = "Option::is_none")]
1727    pub page_token: Option<String>,
1728    /// Contract field principal.
1729    #[serde(rename = "principal")]
1730    pub principal: String,
1731    /// Contract field projectId.
1732    #[serde(rename = "projectId")]
1733    #[serde(default, skip_serializing_if = "Option::is_none")]
1734    pub project_id: Option<String>,
1735}
1736impl<'de> DeserializeStrict<'de> for GlobalMountsRequest {
1737    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1738        #[derive(Deserialize)]
1739        #[serde(deny_unknown_fields)]
1740        struct __Wire {
1741            #[serde(rename = "fsLoc")]
1742            fs_loc: Strict<String>,
1743            #[serde(rename = "pageSize")]
1744            #[serde(default)]
1745            page_size: Strict<Option<u32>>,
1746            #[serde(rename = "pageToken")]
1747            #[serde(default)]
1748            page_token: Strict<Option<String>>,
1749            #[serde(rename = "principal")]
1750            principal: Strict<String>,
1751            #[serde(rename = "projectId")]
1752            #[serde(default)]
1753            project_id: Strict<Option<String>>,
1754        }
1755        let wire = __Wire::deserialize(deserializer)?;
1756        Ok(Self {
1757            fs_loc: wire.fs_loc.0,
1758            page_size: wire.page_size.0,
1759            page_token: wire.page_token.0,
1760            principal: wire.principal.0,
1761            project_id: wire.project_id.0,
1762        })
1763    }
1764}
1765
1766/// HuggingFaceCredential contract value.
1767#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1768pub struct HuggingFaceCredential {
1769    /// Contract field endpoint.
1770    #[serde(rename = "endpoint")]
1771    #[serde(default, skip_serializing_if = "Option::is_none")]
1772    pub endpoint: Option<String>,
1773    /// Contract field token.
1774    #[serde(rename = "token")]
1775    pub token: SecretToken,
1776}
1777impl<'de> DeserializeStrict<'de> for HuggingFaceCredential {
1778    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1779        #[derive(Deserialize)]
1780        #[serde(deny_unknown_fields)]
1781        struct __Wire {
1782            #[serde(rename = "endpoint")]
1783            #[serde(default)]
1784            endpoint: Strict<Option<String>>,
1785            #[serde(rename = "token")]
1786            token: Strict<SecretToken>,
1787        }
1788        let wire = __Wire::deserialize(deserializer)?;
1789        Ok(Self {
1790            endpoint: wire.endpoint.0,
1791            token: wire.token.0,
1792        })
1793    }
1794}
1795
1796/// HuggingFaceCredentialConfig contract value.
1797#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1798pub struct HuggingFaceCredentialConfig {
1799    /// Contract field endpoint.
1800    #[serde(rename = "endpoint")]
1801    #[serde(default, skip_serializing_if = "Option::is_none")]
1802    pub endpoint: Option<String>,
1803}
1804impl<'de> DeserializeStrict<'de> for HuggingFaceCredentialConfig {
1805    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1806        #[derive(Deserialize)]
1807        #[serde(deny_unknown_fields)]
1808        struct __Wire {
1809            #[serde(rename = "endpoint")]
1810            #[serde(default)]
1811            endpoint: Strict<Option<String>>,
1812        }
1813        let wire = __Wire::deserialize(deserializer)?;
1814        Ok(Self {
1815            endpoint: wire.endpoint.0,
1816        })
1817    }
1818}
1819
1820/// IssueMountTokenRequest contract value.
1821#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1822pub struct IssueMountTokenRequest {
1823    /// Contract field mode.
1824    #[serde(rename = "mode")]
1825    pub mode: MountMode,
1826    /// Contract field path.
1827    #[serde(rename = "path")]
1828    pub path: String,
1829}
1830impl<'de> DeserializeStrict<'de> for IssueMountTokenRequest {
1831    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1832        #[derive(Deserialize)]
1833        #[serde(deny_unknown_fields)]
1834        struct __Wire {
1835            #[serde(rename = "mode")]
1836            mode: Strict<MountMode>,
1837            #[serde(rename = "path")]
1838            path: Strict<String>,
1839        }
1840        let wire = __Wire::deserialize(deserializer)?;
1841        Ok(Self {
1842            mode: wire.mode.0,
1843            path: wire.path.0,
1844        })
1845    }
1846}
1847
1848/// IssueMountTokenResponse contract value.
1849#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1850pub struct IssueMountTokenResponse {
1851    /// Contract field token.
1852    #[serde(rename = "token")]
1853    pub token: SecretToken,
1854}
1855impl<'de> DeserializeStrict<'de> for IssueMountTokenResponse {
1856    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1857        #[derive(Deserialize)]
1858        #[serde(deny_unknown_fields)]
1859        struct __Wire {
1860            #[serde(rename = "token")]
1861            token: Strict<SecretToken>,
1862        }
1863        let wire = __Wire::deserialize(deserializer)?;
1864        Ok(Self {
1865            token: wire.token.0,
1866        })
1867    }
1868}
1869
1870/// Mount contract value.
1871#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1872pub struct Mount {
1873    /// Contract field alias.
1874    #[serde(rename = "alias")]
1875    pub alias: Uuid,
1876    /// Contract field belongsTo.
1877    #[serde(rename = "belongsTo")]
1878    #[serde(default, skip_serializing_if = "Option::is_none")]
1879    pub belongs_to: Option<String>,
1880    /// Contract field directory.
1881    #[serde(rename = "directory")]
1882    pub directory: String,
1883    /// Contract field fileSystemId.
1884    #[serde(rename = "fileSystemId")]
1885    #[serde(default, skip_serializing_if = "Option::is_none")]
1886    pub file_system_id: Option<String>,
1887    /// Contract field id.
1888    #[serde(rename = "id")]
1889    pub id: String,
1890    /// Contract field mode.
1891    #[serde(rename = "mode")]
1892    pub mode: MountMode,
1893    /// Contract field principal.
1894    #[serde(rename = "principal")]
1895    pub principal: String,
1896    /// Contract field projectId.
1897    #[serde(rename = "projectId")]
1898    pub project_id: String,
1899}
1900impl<'de> DeserializeStrict<'de> for Mount {
1901    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1902        #[derive(Deserialize)]
1903        #[serde(deny_unknown_fields)]
1904        struct __Wire {
1905            #[serde(rename = "alias")]
1906            alias: Strict<Uuid>,
1907            #[serde(rename = "belongsTo")]
1908            #[serde(default)]
1909            belongs_to: Strict<Option<String>>,
1910            #[serde(rename = "directory")]
1911            directory: Strict<String>,
1912            #[serde(rename = "fileSystemId")]
1913            #[serde(default)]
1914            file_system_id: Strict<Option<String>>,
1915            #[serde(rename = "id")]
1916            id: Strict<String>,
1917            #[serde(rename = "mode")]
1918            mode: Strict<MountMode>,
1919            #[serde(rename = "principal")]
1920            principal: Strict<String>,
1921            #[serde(rename = "projectId")]
1922            project_id: Strict<String>,
1923        }
1924        let wire = __Wire::deserialize(deserializer)?;
1925        Ok(Self {
1926            alias: wire.alias.0,
1927            belongs_to: wire.belongs_to.0,
1928            directory: wire.directory.0,
1929            file_system_id: wire.file_system_id.0,
1930            id: wire.id.0,
1931            mode: wire.mode.0,
1932            principal: wire.principal.0,
1933            project_id: wire.project_id.0,
1934        })
1935    }
1936}
1937
1938/// MountMode contract value.
1939#[derive(Clone, Debug, PartialEq, Eq)]
1940pub enum MountMode {
1941    /// A known contract value.
1942    Ro,
1943    /// A known contract value.
1944    Rw,
1945    /// A value introduced by a newer server.
1946    Unknown(String),
1947}
1948impl Serialize for MountMode {
1949    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1950        serializer.serialize_str(match self {
1951            Self::Ro => "ro",
1952            Self::Rw => "rw",
1953            Self::Unknown(value) => value,
1954        })
1955    }
1956}
1957impl<'de> Deserialize<'de> for MountMode {
1958    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1959        Ok(match String::deserialize(deserializer)?.as_str() {
1960            "ro" => Self::Ro,
1961            "rw" => Self::Rw,
1962            value => Self::Unknown(value.to_owned()),
1963        })
1964    }
1965}
1966impl<'de> DeserializeStrict<'de> for MountMode {
1967    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1968        #[derive(Deserialize)]
1969        enum __Known {
1970            #[serde(rename = "ro")]
1971            Ro,
1972            #[serde(rename = "rw")]
1973            Rw,
1974        }
1975        Ok(match __Known::deserialize(deserializer)? {
1976            __Known::Ro => Self::Ro,
1977            __Known::Rw => Self::Rw,
1978        })
1979    }
1980}
1981
1982/// MountPage contract value.
1983#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1984pub struct MountPage {
1985    /// Contract field items.
1986    #[serde(rename = "items")]
1987    pub items: Vec<Mount>,
1988    /// Contract field nextPageToken.
1989    #[serde(rename = "nextPageToken")]
1990    #[serde(default, skip_serializing_if = "Option::is_none")]
1991    pub next_page_token: Option<String>,
1992}
1993impl<'de> DeserializeStrict<'de> for MountPage {
1994    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1995        #[derive(Deserialize)]
1996        #[serde(deny_unknown_fields)]
1997        struct __Wire {
1998            #[serde(rename = "items")]
1999            items: Strict<Vec<Mount>>,
2000            #[serde(rename = "nextPageToken")]
2001            #[serde(default)]
2002            next_page_token: Strict<Option<String>>,
2003        }
2004        let wire = __Wire::deserialize(deserializer)?;
2005        Ok(Self {
2006            items: wire.items.0,
2007            next_page_token: wire.next_page_token.0,
2008        })
2009    }
2010}
2011
2012/// PageRequest contract value.
2013#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2014pub struct PageRequest {
2015    /// Contract field pageSize.
2016    #[serde(rename = "pageSize")]
2017    #[serde(default, skip_serializing_if = "Option::is_none")]
2018    pub page_size: Option<u32>,
2019    /// Contract field pageToken.
2020    #[serde(rename = "pageToken")]
2021    #[serde(default, skip_serializing_if = "Option::is_none")]
2022    pub page_token: Option<String>,
2023}
2024impl<'de> DeserializeStrict<'de> for PageRequest {
2025    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2026        #[derive(Deserialize)]
2027        #[serde(deny_unknown_fields)]
2028        struct __Wire {
2029            #[serde(rename = "pageSize")]
2030            #[serde(default)]
2031            page_size: Strict<Option<u32>>,
2032            #[serde(rename = "pageToken")]
2033            #[serde(default)]
2034            page_token: Strict<Option<String>>,
2035        }
2036        let wire = __Wire::deserialize(deserializer)?;
2037        Ok(Self {
2038            page_size: wire.page_size.0,
2039            page_token: wire.page_token.0,
2040        })
2041    }
2042}
2043
2044/// ProjectStorage contract value.
2045#[derive(Clone, Debug, PartialEq, Eq)]
2046pub enum ProjectStorage {
2047    /// A known union arm.
2048    FileSystem(ProjectStorageFileSystem),
2049    /// A known union arm.
2050    Volume(ProjectStorageVolume),
2051    /// An unknown discriminator and its complete wire object.
2052    Unknown { tag: String, value: Value },
2053}
2054impl Serialize for ProjectStorage {
2055    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2056        match self {
2057            Self::FileSystem(value) => {
2058                let mut object = serde_json::Map::new();
2059                object.insert("type".into(), Value::String("fileSystem".into()));
2060                object.insert(
2061                    "fileSystem".into(),
2062                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2063                );
2064                Value::Object(object).serialize(serializer)
2065            }
2066            Self::Volume(value) => {
2067                let mut object = serde_json::Map::new();
2068                object.insert("type".into(), Value::String("volume".into()));
2069                object.insert(
2070                    "volume".into(),
2071                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2072                );
2073                Value::Object(object).serialize(serializer)
2074            }
2075            Self::Unknown { tag, value } => {
2076                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
2077                    return Err(serde::ser::Error::custom(
2078                        "unknown union discriminator mismatch",
2079                    ));
2080                }
2081                value.serialize(serializer)
2082            }
2083        }
2084    }
2085}
2086impl<'de> Deserialize<'de> for ProjectStorage {
2087    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2088        let value = Value::deserialize(deserializer)?;
2089        let tag = value
2090            .get("type")
2091            .and_then(Value::as_str)
2092            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
2093        match tag {
2094            "fileSystem" => Ok(Self::FileSystem(
2095                serde_json::from_value(
2096                    value
2097                        .get("fileSystem")
2098                        .cloned()
2099                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2100                )
2101                .map_err(serde::de::Error::custom)?,
2102            )),
2103            "volume" => Ok(Self::Volume(
2104                serde_json::from_value(
2105                    value
2106                        .get("volume")
2107                        .cloned()
2108                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2109                )
2110                .map_err(serde::de::Error::custom)?,
2111            )),
2112            tag => Ok(Self::Unknown {
2113                tag: tag.to_owned(),
2114                value,
2115            }),
2116        }
2117    }
2118}
2119impl<'de> DeserializeStrict<'de> for ProjectStorage {
2120    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2121        #[derive(Deserialize)]
2122        enum __Tag0 {
2123            #[serde(rename = "fileSystem")]
2124            Value,
2125        }
2126        #[derive(Deserialize)]
2127        #[serde(deny_unknown_fields)]
2128        struct __Arm0 {
2129            #[serde(rename = "type")]
2130            _tag: __Tag0,
2131            #[serde(rename = "fileSystem")]
2132            value: Strict<ProjectStorageFileSystem>,
2133        }
2134        #[derive(Deserialize)]
2135        enum __Tag1 {
2136            #[serde(rename = "volume")]
2137            Value,
2138        }
2139        #[derive(Deserialize)]
2140        #[serde(deny_unknown_fields)]
2141        struct __Arm1 {
2142            #[serde(rename = "type")]
2143            _tag: __Tag1,
2144            #[serde(rename = "volume")]
2145            value: Strict<ProjectStorageVolume>,
2146        }
2147        #[derive(Deserialize)]
2148        #[serde(untagged)]
2149        enum __Known {
2150            FileSystem(Box<__Arm0>),
2151            Volume(Box<__Arm1>),
2152        }
2153        Ok(match __Known::deserialize(deserializer)? {
2154            __Known::FileSystem(arm) => Self::FileSystem(arm.value.0),
2155            __Known::Volume(arm) => Self::Volume(arm.value.0),
2156        })
2157    }
2158}
2159
2160/// ProjectStorageFileSystem contract value.
2161#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2162pub struct ProjectStorageFileSystem {}
2163impl<'de> DeserializeStrict<'de> for ProjectStorageFileSystem {
2164    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2165        #[derive(Deserialize)]
2166        #[serde(deny_unknown_fields)]
2167        struct __Wire {}
2168        __Wire::deserialize(deserializer)?;
2169        Ok(Self {})
2170    }
2171}
2172
2173/// ProjectStorageView contract value.
2174#[derive(Clone, Debug, PartialEq, Eq)]
2175pub enum ProjectStorageView {
2176    /// A known union arm.
2177    FileSystem(ProjectStorageViewFileSystem),
2178    /// A known union arm.
2179    Volume(ProjectStorageViewVolume),
2180    /// An unknown discriminator and its complete wire object.
2181    Unknown { tag: String, value: Value },
2182}
2183impl Serialize for ProjectStorageView {
2184    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2185        match self {
2186            Self::FileSystem(value) => {
2187                let mut object = serde_json::Map::new();
2188                object.insert("type".into(), Value::String("fileSystem".into()));
2189                object.insert(
2190                    "fileSystem".into(),
2191                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2192                );
2193                Value::Object(object).serialize(serializer)
2194            }
2195            Self::Volume(value) => {
2196                let mut object = serde_json::Map::new();
2197                object.insert("type".into(), Value::String("volume".into()));
2198                object.insert(
2199                    "volume".into(),
2200                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2201                );
2202                Value::Object(object).serialize(serializer)
2203            }
2204            Self::Unknown { tag, value } => {
2205                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
2206                    return Err(serde::ser::Error::custom(
2207                        "unknown union discriminator mismatch",
2208                    ));
2209                }
2210                value.serialize(serializer)
2211            }
2212        }
2213    }
2214}
2215impl<'de> Deserialize<'de> for ProjectStorageView {
2216    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2217        let value = Value::deserialize(deserializer)?;
2218        let tag = value
2219            .get("type")
2220            .and_then(Value::as_str)
2221            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
2222        match tag {
2223            "fileSystem" => Ok(Self::FileSystem(
2224                serde_json::from_value(
2225                    value
2226                        .get("fileSystem")
2227                        .cloned()
2228                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2229                )
2230                .map_err(serde::de::Error::custom)?,
2231            )),
2232            "volume" => Ok(Self::Volume(
2233                serde_json::from_value(
2234                    value
2235                        .get("volume")
2236                        .cloned()
2237                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2238                )
2239                .map_err(serde::de::Error::custom)?,
2240            )),
2241            tag => Ok(Self::Unknown {
2242                tag: tag.to_owned(),
2243                value,
2244            }),
2245        }
2246    }
2247}
2248impl<'de> DeserializeStrict<'de> for ProjectStorageView {
2249    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2250        #[derive(Deserialize)]
2251        enum __Tag0 {
2252            #[serde(rename = "fileSystem")]
2253            Value,
2254        }
2255        #[derive(Deserialize)]
2256        #[serde(deny_unknown_fields)]
2257        struct __Arm0 {
2258            #[serde(rename = "type")]
2259            _tag: __Tag0,
2260            #[serde(rename = "fileSystem")]
2261            value: Strict<ProjectStorageViewFileSystem>,
2262        }
2263        #[derive(Deserialize)]
2264        enum __Tag1 {
2265            #[serde(rename = "volume")]
2266            Value,
2267        }
2268        #[derive(Deserialize)]
2269        #[serde(deny_unknown_fields)]
2270        struct __Arm1 {
2271            #[serde(rename = "type")]
2272            _tag: __Tag1,
2273            #[serde(rename = "volume")]
2274            value: Strict<ProjectStorageViewVolume>,
2275        }
2276        #[derive(Deserialize)]
2277        #[serde(untagged)]
2278        enum __Known {
2279            FileSystem(Box<__Arm0>),
2280            Volume(Box<__Arm1>),
2281        }
2282        Ok(match __Known::deserialize(deserializer)? {
2283            __Known::FileSystem(arm) => Self::FileSystem(arm.value.0),
2284            __Known::Volume(arm) => Self::Volume(arm.value.0),
2285        })
2286    }
2287}
2288
2289/// ProjectStorageViewFileSystem contract value.
2290#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2291pub struct ProjectStorageViewFileSystem {}
2292impl<'de> DeserializeStrict<'de> for ProjectStorageViewFileSystem {
2293    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2294        #[derive(Deserialize)]
2295        #[serde(deny_unknown_fields)]
2296        struct __Wire {}
2297        __Wire::deserialize(deserializer)?;
2298        Ok(Self {})
2299    }
2300}
2301
2302/// ProjectStorageViewVolume contract value.
2303#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2304pub struct ProjectStorageViewVolume {
2305    /// Contract field selected.
2306    #[serde(rename = "selected")]
2307    pub selected: bool,
2308    /// Contract field volumeId.
2309    #[serde(rename = "volumeId")]
2310    pub volume_id: String,
2311}
2312impl<'de> DeserializeStrict<'de> for ProjectStorageViewVolume {
2313    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2314        #[derive(Deserialize)]
2315        #[serde(deny_unknown_fields)]
2316        struct __Wire {
2317            #[serde(rename = "selected")]
2318            selected: Strict<bool>,
2319            #[serde(rename = "volumeId")]
2320            volume_id: Strict<String>,
2321        }
2322        let wire = __Wire::deserialize(deserializer)?;
2323        Ok(Self {
2324            selected: wire.selected.0,
2325            volume_id: wire.volume_id.0,
2326        })
2327    }
2328}
2329
2330/// ProjectStorageVolume contract value.
2331#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2332pub struct ProjectStorageVolume {
2333    /// Contract field volumeId.
2334    #[serde(rename = "volumeId")]
2335    pub volume_id: String,
2336}
2337impl<'de> DeserializeStrict<'de> for ProjectStorageVolume {
2338    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2339        #[derive(Deserialize)]
2340        #[serde(deny_unknown_fields)]
2341        struct __Wire {
2342            #[serde(rename = "volumeId")]
2343            volume_id: Strict<String>,
2344        }
2345        let wire = __Wire::deserialize(deserializer)?;
2346        Ok(Self {
2347            volume_id: wire.volume_id.0,
2348        })
2349    }
2350}
2351
2352/// R2AccessKey contract value.
2353#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2354pub struct R2AccessKey {
2355    /// Contract field accessKeyId.
2356    #[serde(rename = "accessKeyId")]
2357    pub access_key_id: String,
2358    /// Contract field accountId.
2359    #[serde(rename = "accountId")]
2360    pub account_id: String,
2361    /// Contract field jurisdiction.
2362    #[serde(rename = "jurisdiction")]
2363    #[serde(default, skip_serializing_if = "Option::is_none")]
2364    pub jurisdiction: Option<R2Jurisdiction>,
2365    /// Contract field secretAccessKey.
2366    #[serde(rename = "secretAccessKey")]
2367    pub secret_access_key: SecretToken,
2368}
2369impl<'de> DeserializeStrict<'de> for R2AccessKey {
2370    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2371        #[derive(Deserialize)]
2372        #[serde(deny_unknown_fields)]
2373        struct __Wire {
2374            #[serde(rename = "accessKeyId")]
2375            access_key_id: Strict<String>,
2376            #[serde(rename = "accountId")]
2377            account_id: Strict<String>,
2378            #[serde(rename = "jurisdiction")]
2379            #[serde(default)]
2380            jurisdiction: Strict<Option<R2Jurisdiction>>,
2381            #[serde(rename = "secretAccessKey")]
2382            secret_access_key: Strict<SecretToken>,
2383        }
2384        let wire = __Wire::deserialize(deserializer)?;
2385        Ok(Self {
2386            access_key_id: wire.access_key_id.0,
2387            account_id: wire.account_id.0,
2388            jurisdiction: wire.jurisdiction.0,
2389            secret_access_key: wire.secret_access_key.0,
2390        })
2391    }
2392}
2393
2394/// R2AccessKeyConfig contract value.
2395#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2396pub struct R2AccessKeyConfig {
2397    /// Contract field accessKeyId.
2398    #[serde(rename = "accessKeyId")]
2399    pub access_key_id: String,
2400    /// Contract field accountId.
2401    #[serde(rename = "accountId")]
2402    pub account_id: String,
2403    /// Contract field jurisdiction.
2404    #[serde(rename = "jurisdiction")]
2405    #[serde(default, skip_serializing_if = "Option::is_none")]
2406    pub jurisdiction: Option<R2Jurisdiction>,
2407}
2408impl<'de> DeserializeStrict<'de> for R2AccessKeyConfig {
2409    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2410        #[derive(Deserialize)]
2411        #[serde(deny_unknown_fields)]
2412        struct __Wire {
2413            #[serde(rename = "accessKeyId")]
2414            access_key_id: Strict<String>,
2415            #[serde(rename = "accountId")]
2416            account_id: Strict<String>,
2417            #[serde(rename = "jurisdiction")]
2418            #[serde(default)]
2419            jurisdiction: Strict<Option<R2Jurisdiction>>,
2420        }
2421        let wire = __Wire::deserialize(deserializer)?;
2422        Ok(Self {
2423            access_key_id: wire.access_key_id.0,
2424            account_id: wire.account_id.0,
2425            jurisdiction: wire.jurisdiction.0,
2426        })
2427    }
2428}
2429
2430/// R2FileSystem contract value.
2431#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2432pub struct R2FileSystem {
2433    /// Contract field accessKeyId.
2434    #[serde(rename = "accessKeyId")]
2435    pub access_key_id: String,
2436    /// Contract field bucket.
2437    #[serde(rename = "bucket")]
2438    pub bucket: String,
2439    /// Contract field directory.
2440    #[serde(rename = "directory")]
2441    pub directory: String,
2442    /// Contract field endpoint.
2443    #[serde(rename = "endpoint")]
2444    pub endpoint: String,
2445    /// Contract field secretAccessKey.
2446    #[serde(rename = "secretAccessKey")]
2447    pub secret_access_key: SecretAccessKey,
2448}
2449impl<'de> DeserializeStrict<'de> for R2FileSystem {
2450    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2451        #[derive(Deserialize)]
2452        #[serde(deny_unknown_fields)]
2453        struct __Wire {
2454            #[serde(rename = "accessKeyId")]
2455            access_key_id: Strict<String>,
2456            #[serde(rename = "bucket")]
2457            bucket: Strict<String>,
2458            #[serde(rename = "directory")]
2459            directory: Strict<String>,
2460            #[serde(rename = "endpoint")]
2461            endpoint: Strict<String>,
2462            #[serde(rename = "secretAccessKey")]
2463            secret_access_key: Strict<SecretAccessKey>,
2464        }
2465        let wire = __Wire::deserialize(deserializer)?;
2466        Ok(Self {
2467            access_key_id: wire.access_key_id.0,
2468            bucket: wire.bucket.0,
2469            directory: wire.directory.0,
2470            endpoint: wire.endpoint.0,
2471            secret_access_key: wire.secret_access_key.0,
2472        })
2473    }
2474}
2475
2476/// R2Jurisdiction contract value.
2477#[derive(Clone, Debug, PartialEq, Eq)]
2478pub enum R2Jurisdiction {
2479    /// A known contract value.
2480    Eu,
2481    /// A known contract value.
2482    Fedramp,
2483    /// A known contract value.
2484    Us,
2485    /// A value introduced by a newer server.
2486    Unknown(String),
2487}
2488impl Serialize for R2Jurisdiction {
2489    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2490        serializer.serialize_str(match self {
2491            Self::Eu => "eu",
2492            Self::Fedramp => "fedramp",
2493            Self::Us => "us",
2494            Self::Unknown(value) => value,
2495        })
2496    }
2497}
2498impl<'de> Deserialize<'de> for R2Jurisdiction {
2499    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2500        Ok(match String::deserialize(deserializer)?.as_str() {
2501            "eu" => Self::Eu,
2502            "fedramp" => Self::Fedramp,
2503            "us" => Self::Us,
2504            value => Self::Unknown(value.to_owned()),
2505        })
2506    }
2507}
2508impl<'de> DeserializeStrict<'de> for R2Jurisdiction {
2509    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2510        #[derive(Deserialize)]
2511        enum __Known {
2512            #[serde(rename = "eu")]
2513            Eu,
2514            #[serde(rename = "fedramp")]
2515            Fedramp,
2516            #[serde(rename = "us")]
2517            Us,
2518        }
2519        Ok(match __Known::deserialize(deserializer)? {
2520            __Known::Eu => Self::Eu,
2521            __Known::Fedramp => Self::Fedramp,
2522            __Known::Us => Self::Us,
2523        })
2524    }
2525}
2526
2527/// RegisterVolumeRequest contract value.
2528#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2529pub struct RegisterVolumeRequest {
2530    /// Contract field credential.
2531    #[serde(rename = "credential")]
2532    pub credential: Credential,
2533    /// Contract field name.
2534    #[serde(rename = "name")]
2535    pub name: String,
2536    /// Contract field region.
2537    #[serde(rename = "region")]
2538    #[serde(default, skip_serializing_if = "Option::is_none")]
2539    pub region: Option<String>,
2540    /// Contract field uri.
2541    #[serde(rename = "uri")]
2542    pub uri: String,
2543}
2544impl<'de> DeserializeStrict<'de> for RegisterVolumeRequest {
2545    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2546        #[derive(Deserialize)]
2547        #[serde(deny_unknown_fields)]
2548        struct __Wire {
2549            #[serde(rename = "credential")]
2550            credential: Strict<Credential>,
2551            #[serde(rename = "name")]
2552            name: Strict<String>,
2553            #[serde(rename = "region")]
2554            #[serde(default)]
2555            region: Strict<Option<String>>,
2556            #[serde(rename = "uri")]
2557            uri: Strict<String>,
2558        }
2559        let wire = __Wire::deserialize(deserializer)?;
2560        Ok(Self {
2561            credential: wire.credential.0,
2562            name: wire.name.0,
2563            region: wire.region.0,
2564            uri: wire.uri.0,
2565        })
2566    }
2567}
2568
2569/// S3AccessKey contract value.
2570#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2571pub struct S3AccessKey {
2572    /// Contract field accessKeyId.
2573    #[serde(rename = "accessKeyId")]
2574    pub access_key_id: String,
2575    /// Contract field endpoint.
2576    #[serde(rename = "endpoint")]
2577    pub endpoint: String,
2578    /// Contract field region.
2579    #[serde(rename = "region")]
2580    #[serde(default, skip_serializing_if = "Option::is_none")]
2581    pub region: Option<String>,
2582    /// Contract field secretAccessKey.
2583    #[serde(rename = "secretAccessKey")]
2584    pub secret_access_key: SecretToken,
2585}
2586impl<'de> DeserializeStrict<'de> for S3AccessKey {
2587    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2588        #[derive(Deserialize)]
2589        #[serde(deny_unknown_fields)]
2590        struct __Wire {
2591            #[serde(rename = "accessKeyId")]
2592            access_key_id: Strict<String>,
2593            #[serde(rename = "endpoint")]
2594            endpoint: Strict<String>,
2595            #[serde(rename = "region")]
2596            #[serde(default)]
2597            region: Strict<Option<String>>,
2598            #[serde(rename = "secretAccessKey")]
2599            secret_access_key: Strict<SecretToken>,
2600        }
2601        let wire = __Wire::deserialize(deserializer)?;
2602        Ok(Self {
2603            access_key_id: wire.access_key_id.0,
2604            endpoint: wire.endpoint.0,
2605            region: wire.region.0,
2606            secret_access_key: wire.secret_access_key.0,
2607        })
2608    }
2609}
2610
2611/// S3AccessKeyConfig contract value.
2612#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2613pub struct S3AccessKeyConfig {
2614    /// Contract field accessKeyId.
2615    #[serde(rename = "accessKeyId")]
2616    pub access_key_id: String,
2617    /// Contract field endpoint.
2618    #[serde(rename = "endpoint")]
2619    pub endpoint: String,
2620    /// Contract field region.
2621    #[serde(rename = "region")]
2622    #[serde(default, skip_serializing_if = "Option::is_none")]
2623    pub region: Option<String>,
2624}
2625impl<'de> DeserializeStrict<'de> for S3AccessKeyConfig {
2626    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2627        #[derive(Deserialize)]
2628        #[serde(deny_unknown_fields)]
2629        struct __Wire {
2630            #[serde(rename = "accessKeyId")]
2631            access_key_id: Strict<String>,
2632            #[serde(rename = "endpoint")]
2633            endpoint: Strict<String>,
2634            #[serde(rename = "region")]
2635            #[serde(default)]
2636            region: Strict<Option<String>>,
2637        }
2638        let wire = __Wire::deserialize(deserializer)?;
2639        Ok(Self {
2640            access_key_id: wire.access_key_id.0,
2641            endpoint: wire.endpoint.0,
2642            region: wire.region.0,
2643        })
2644    }
2645}
2646
2647/// S3FileSystem contract value.
2648#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2649pub struct S3FileSystem {
2650    /// Contract field bucket.
2651    #[serde(rename = "bucket")]
2652    pub bucket: String,
2653    /// Contract field directory.
2654    #[serde(rename = "directory")]
2655    pub directory: String,
2656    /// Contract field endpoint.
2657    #[serde(rename = "endpoint")]
2658    #[serde(default, skip_serializing_if = "Option::is_none")]
2659    pub endpoint: Option<String>,
2660    /// Contract field region.
2661    #[serde(rename = "region")]
2662    pub region: String,
2663    /// Contract field roleArn.
2664    #[serde(rename = "roleArn")]
2665    pub role_arn: String,
2666}
2667impl<'de> DeserializeStrict<'de> for S3FileSystem {
2668    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2669        #[derive(Deserialize)]
2670        #[serde(deny_unknown_fields)]
2671        struct __Wire {
2672            #[serde(rename = "bucket")]
2673            bucket: Strict<String>,
2674            #[serde(rename = "directory")]
2675            directory: Strict<String>,
2676            #[serde(rename = "endpoint")]
2677            #[serde(default)]
2678            endpoint: Strict<Option<String>>,
2679            #[serde(rename = "region")]
2680            region: Strict<String>,
2681            #[serde(rename = "roleArn")]
2682            role_arn: Strict<String>,
2683        }
2684        let wire = __Wire::deserialize(deserializer)?;
2685        Ok(Self {
2686            bucket: wire.bucket.0,
2687            directory: wire.directory.0,
2688            endpoint: wire.endpoint.0,
2689            region: wire.region.0,
2690            role_arn: wire.role_arn.0,
2691        })
2692    }
2693}
2694
2695/// S3LikeFileSystem contract value.
2696#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2697pub struct S3LikeFileSystem {
2698    /// Contract field accessKeyId.
2699    #[serde(rename = "accessKeyId")]
2700    pub access_key_id: String,
2701    /// Contract field bucket.
2702    #[serde(rename = "bucket")]
2703    pub bucket: String,
2704    /// Contract field directory.
2705    #[serde(rename = "directory")]
2706    pub directory: String,
2707    /// Contract field endpoint.
2708    #[serde(rename = "endpoint")]
2709    pub endpoint: String,
2710    /// Contract field region.
2711    #[serde(rename = "region")]
2712    pub region: String,
2713    /// Contract field secretAccessKey.
2714    #[serde(rename = "secretAccessKey")]
2715    pub secret_access_key: SecretAccessKey,
2716}
2717impl<'de> DeserializeStrict<'de> for S3LikeFileSystem {
2718    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2719        #[derive(Deserialize)]
2720        #[serde(deny_unknown_fields)]
2721        struct __Wire {
2722            #[serde(rename = "accessKeyId")]
2723            access_key_id: Strict<String>,
2724            #[serde(rename = "bucket")]
2725            bucket: Strict<String>,
2726            #[serde(rename = "directory")]
2727            directory: Strict<String>,
2728            #[serde(rename = "endpoint")]
2729            endpoint: Strict<String>,
2730            #[serde(rename = "region")]
2731            region: Strict<String>,
2732            #[serde(rename = "secretAccessKey")]
2733            secret_access_key: Strict<SecretAccessKey>,
2734        }
2735        let wire = __Wire::deserialize(deserializer)?;
2736        Ok(Self {
2737            access_key_id: wire.access_key_id.0,
2738            bucket: wire.bucket.0,
2739            directory: wire.directory.0,
2740            endpoint: wire.endpoint.0,
2741            region: wire.region.0,
2742            secret_access_key: wire.secret_access_key.0,
2743        })
2744    }
2745}
2746
2747/// SecretAccessKey contract value.
2748#[derive(Clone, Debug, PartialEq, Eq)]
2749pub enum SecretAccessKey {
2750    /// A known union arm.
2751    Secret(String),
2752    /// A known union arm.
2753    Token(SecretToken),
2754    /// An unknown discriminator and its complete wire object.
2755    Unknown { tag: String, value: Value },
2756}
2757impl Serialize for SecretAccessKey {
2758    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2759        match self {
2760            Self::Secret(value) => {
2761                let mut object = serde_json::Map::new();
2762                object.insert("type".into(), Value::String("secret".into()));
2763                object.insert(
2764                    "secret".into(),
2765                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2766                );
2767                Value::Object(object).serialize(serializer)
2768            }
2769            Self::Token(value) => {
2770                let mut object = serde_json::Map::new();
2771                object.insert("type".into(), Value::String("token".into()));
2772                object.insert(
2773                    "token".into(),
2774                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2775                );
2776                Value::Object(object).serialize(serializer)
2777            }
2778            Self::Unknown { tag, value } => {
2779                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
2780                    return Err(serde::ser::Error::custom(
2781                        "unknown union discriminator mismatch",
2782                    ));
2783                }
2784                value.serialize(serializer)
2785            }
2786        }
2787    }
2788}
2789impl<'de> Deserialize<'de> for SecretAccessKey {
2790    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2791        let value = Value::deserialize(deserializer)?;
2792        let tag = value
2793            .get("type")
2794            .and_then(Value::as_str)
2795            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
2796        match tag {
2797            "secret" => Ok(Self::Secret(
2798                serde_json::from_value(
2799                    value
2800                        .get("secret")
2801                        .cloned()
2802                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2803                )
2804                .map_err(serde::de::Error::custom)?,
2805            )),
2806            "token" => Ok(Self::Token(
2807                serde_json::from_value(
2808                    value
2809                        .get("token")
2810                        .cloned()
2811                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2812                )
2813                .map_err(serde::de::Error::custom)?,
2814            )),
2815            tag => Ok(Self::Unknown {
2816                tag: tag.to_owned(),
2817                value,
2818            }),
2819        }
2820    }
2821}
2822impl<'de> DeserializeStrict<'de> for SecretAccessKey {
2823    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2824        #[derive(Deserialize)]
2825        enum __Tag0 {
2826            #[serde(rename = "secret")]
2827            Value,
2828        }
2829        #[derive(Deserialize)]
2830        #[serde(deny_unknown_fields)]
2831        struct __Arm0 {
2832            #[serde(rename = "type")]
2833            _tag: __Tag0,
2834            #[serde(rename = "secret")]
2835            value: Strict<String>,
2836        }
2837        #[derive(Deserialize)]
2838        enum __Tag1 {
2839            #[serde(rename = "token")]
2840            Value,
2841        }
2842        #[derive(Deserialize)]
2843        #[serde(deny_unknown_fields)]
2844        struct __Arm1 {
2845            #[serde(rename = "type")]
2846            _tag: __Tag1,
2847            #[serde(rename = "token")]
2848            value: Strict<SecretToken>,
2849        }
2850        #[derive(Deserialize)]
2851        #[serde(untagged)]
2852        enum __Known {
2853            Secret(Box<__Arm0>),
2854            Token(Box<__Arm1>),
2855        }
2856        Ok(match __Known::deserialize(deserializer)? {
2857            __Known::Secret(arm) => Self::Secret(arm.value.0),
2858            __Known::Token(arm) => Self::Token(arm.value.0),
2859        })
2860    }
2861}
2862
2863/// A secret credential or scoped access token.
2864#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
2865#[serde(transparent)]
2866pub struct SecretToken(pub String);
2867impl std::fmt::Debug for SecretToken {
2868    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2869        formatter.write_str("SecretToken(<redacted>)")
2870    }
2871}
2872impl<'de> DeserializeStrict<'de> for SecretToken {
2873    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2874        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
2875    }
2876}
2877
2878/// The outcome of one step of a Volume test.
2879#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2880pub struct TestStep {
2881    /// Contract field detail.
2882    #[serde(rename = "detail")]
2883    pub detail: String,
2884    /// Contract field succeeded.
2885    #[serde(rename = "succeeded")]
2886    pub succeeded: bool,
2887}
2888impl<'de> DeserializeStrict<'de> for TestStep {
2889    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2890        #[derive(Deserialize)]
2891        #[serde(deny_unknown_fields)]
2892        struct __Wire {
2893            #[serde(rename = "detail")]
2894            detail: Strict<String>,
2895            #[serde(rename = "succeeded")]
2896            succeeded: Strict<bool>,
2897        }
2898        let wire = __Wire::deserialize(deserializer)?;
2899        Ok(Self {
2900            detail: wire.detail.0,
2901            succeeded: wire.succeeded.0,
2902        })
2903    }
2904}
2905
2906/// A Volume test, one entry per step. A refused step is reported as data, not as an error.
2907#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2908pub struct TestVolumeResponse {
2909    /// Contract field access.
2910    #[serde(rename = "access")]
2911    #[serde(default, skip_serializing_if = "Option::is_none")]
2912    pub access: Option<TestStep>,
2913    /// Contract field vend.
2914    #[serde(rename = "vend")]
2915    pub vend: TestStep,
2916    /// Contract field write.
2917    #[serde(rename = "write")]
2918    #[serde(default, skip_serializing_if = "Option::is_none")]
2919    pub write: Option<TestStep>,
2920}
2921impl<'de> DeserializeStrict<'de> for TestVolumeResponse {
2922    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2923        #[derive(Deserialize)]
2924        #[serde(deny_unknown_fields)]
2925        struct __Wire {
2926            #[serde(rename = "access")]
2927            #[serde(default)]
2928            access: Strict<Option<TestStep>>,
2929            #[serde(rename = "vend")]
2930            vend: Strict<TestStep>,
2931            #[serde(rename = "write")]
2932            #[serde(default)]
2933            write: Strict<Option<TestStep>>,
2934        }
2935        let wire = __Wire::deserialize(deserializer)?;
2936        Ok(Self {
2937            access: wire.access.0,
2938            vend: wire.vend.0,
2939            write: wire.write.0,
2940        })
2941    }
2942}
2943
2944/// UpdateVolumeCredentialRequest contract value.
2945#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2946pub struct UpdateVolumeCredentialRequest {
2947    /// Contract field credential.
2948    #[serde(rename = "credential")]
2949    pub credential: Credential,
2950}
2951impl<'de> DeserializeStrict<'de> for UpdateVolumeCredentialRequest {
2952    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2953        #[derive(Deserialize)]
2954        #[serde(deny_unknown_fields)]
2955        struct __Wire {
2956            #[serde(rename = "credential")]
2957            credential: Strict<Credential>,
2958        }
2959        let wire = __Wire::deserialize(deserializer)?;
2960        Ok(Self {
2961            credential: wire.credential.0,
2962        })
2963    }
2964}
2965
2966/// UpdateVolumeStatusRequest contract value.
2967#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2968pub struct UpdateVolumeStatusRequest {
2969    /// Contract field status.
2970    #[serde(rename = "status")]
2971    pub status: VolumeStatus,
2972}
2973impl<'de> DeserializeStrict<'de> for UpdateVolumeStatusRequest {
2974    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2975        #[derive(Deserialize)]
2976        #[serde(deny_unknown_fields)]
2977        struct __Wire {
2978            #[serde(rename = "status")]
2979            status: Strict<VolumeStatus>,
2980        }
2981        let wire = __Wire::deserialize(deserializer)?;
2982        Ok(Self {
2983            status: wire.status.0,
2984        })
2985    }
2986}
2987
2988/// UpstreamFileSystem contract value.
2989#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2990pub struct UpstreamFileSystem {
2991    /// Contract field projectId.
2992    #[serde(rename = "projectId")]
2993    pub project_id: String,
2994}
2995impl<'de> DeserializeStrict<'de> for UpstreamFileSystem {
2996    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2997        #[derive(Deserialize)]
2998        #[serde(deny_unknown_fields)]
2999        struct __Wire {
3000            #[serde(rename = "projectId")]
3001            project_id: Strict<String>,
3002        }
3003        let wire = __Wire::deserialize(deserializer)?;
3004        Ok(Self {
3005            project_id: wire.project_id.0,
3006        })
3007    }
3008}
3009
3010/// VolumeDetails contract value.
3011#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
3012pub struct VolumeDetails {
3013    /// Contract field credential.
3014    #[serde(rename = "credential")]
3015    pub credential: CredentialConfig,
3016    /// Contract field identity.
3017    #[serde(rename = "identity")]
3018    #[serde(default, skip_serializing_if = "Option::is_none")]
3019    pub identity: Option<VolumeIdentity>,
3020    /// Contract field region.
3021    #[serde(rename = "region")]
3022    #[serde(default, skip_serializing_if = "Option::is_none")]
3023    pub region: Option<String>,
3024    /// Contract field status.
3025    #[serde(rename = "status")]
3026    pub status: VolumeStatus,
3027    /// Contract field uri.
3028    #[serde(rename = "uri")]
3029    pub uri: String,
3030}
3031impl<'de> DeserializeStrict<'de> for VolumeDetails {
3032    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3033        #[derive(Deserialize)]
3034        #[serde(deny_unknown_fields)]
3035        struct __Wire {
3036            #[serde(rename = "credential")]
3037            credential: Strict<CredentialConfig>,
3038            #[serde(rename = "identity")]
3039            #[serde(default)]
3040            identity: Strict<Option<VolumeIdentity>>,
3041            #[serde(rename = "region")]
3042            #[serde(default)]
3043            region: Strict<Option<String>>,
3044            #[serde(rename = "status")]
3045            status: Strict<VolumeStatus>,
3046            #[serde(rename = "uri")]
3047            uri: Strict<String>,
3048        }
3049        let wire = __Wire::deserialize(deserializer)?;
3050        Ok(Self {
3051            credential: wire.credential.0,
3052            identity: wire.identity.0,
3053            region: wire.region.0,
3054            status: wire.status.0,
3055            uri: wire.uri.0,
3056        })
3057    }
3058}
3059
3060/// VolumeIdentity contract value.
3061#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
3062pub struct VolumeIdentity {
3063    /// Contract field audience.
3064    #[serde(rename = "audience")]
3065    pub audience: String,
3066    /// Contract field issuer.
3067    #[serde(rename = "issuer")]
3068    pub issuer: String,
3069    /// Contract field subject.
3070    #[serde(rename = "subject")]
3071    pub subject: String,
3072    /// Contract field trustPolicy.
3073    #[serde(rename = "trustPolicy")]
3074    pub trust_policy: String,
3075}
3076impl<'de> DeserializeStrict<'de> for VolumeIdentity {
3077    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3078        #[derive(Deserialize)]
3079        #[serde(deny_unknown_fields)]
3080        struct __Wire {
3081            #[serde(rename = "audience")]
3082            audience: Strict<String>,
3083            #[serde(rename = "issuer")]
3084            issuer: Strict<String>,
3085            #[serde(rename = "subject")]
3086            subject: Strict<String>,
3087            #[serde(rename = "trustPolicy")]
3088            trust_policy: Strict<String>,
3089        }
3090        let wire = __Wire::deserialize(deserializer)?;
3091        Ok(Self {
3092            audience: wire.audience.0,
3093            issuer: wire.issuer.0,
3094            subject: wire.subject.0,
3095            trust_policy: wire.trust_policy.0,
3096        })
3097    }
3098}
3099
3100/// VolumePage contract value.
3101#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
3102pub struct VolumePage {
3103    /// Contract field items.
3104    #[serde(rename = "items")]
3105    pub items: Vec<VolumeView>,
3106    /// Contract field nextPageToken.
3107    #[serde(rename = "nextPageToken")]
3108    #[serde(default, skip_serializing_if = "Option::is_none")]
3109    pub next_page_token: Option<String>,
3110}
3111impl<'de> DeserializeStrict<'de> for VolumePage {
3112    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3113        #[derive(Deserialize)]
3114        #[serde(deny_unknown_fields)]
3115        struct __Wire {
3116            #[serde(rename = "items")]
3117            items: Strict<Vec<VolumeView>>,
3118            #[serde(rename = "nextPageToken")]
3119            #[serde(default)]
3120            next_page_token: Strict<Option<String>>,
3121        }
3122        let wire = __Wire::deserialize(deserializer)?;
3123        Ok(Self {
3124            items: wire.items.0,
3125            next_page_token: wire.next_page_token.0,
3126        })
3127    }
3128}
3129
3130/// VolumeStatus contract value.
3131#[derive(Clone, Debug, PartialEq, Eq)]
3132pub enum VolumeStatus {
3133    /// A known contract value.
3134    Active,
3135    /// A known contract value.
3136    Retired,
3137    /// A known contract value.
3138    Revoked,
3139    /// A value introduced by a newer server.
3140    Unknown(String),
3141}
3142impl Serialize for VolumeStatus {
3143    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3144        serializer.serialize_str(match self {
3145            Self::Active => "active",
3146            Self::Retired => "retired",
3147            Self::Revoked => "revoked",
3148            Self::Unknown(value) => value,
3149        })
3150    }
3151}
3152impl<'de> Deserialize<'de> for VolumeStatus {
3153    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3154        Ok(match String::deserialize(deserializer)?.as_str() {
3155            "active" => Self::Active,
3156            "retired" => Self::Retired,
3157            "revoked" => Self::Revoked,
3158            value => Self::Unknown(value.to_owned()),
3159        })
3160    }
3161}
3162impl<'de> DeserializeStrict<'de> for VolumeStatus {
3163    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3164        #[derive(Deserialize)]
3165        enum __Known {
3166            #[serde(rename = "active")]
3167            Active,
3168            #[serde(rename = "retired")]
3169            Retired,
3170            #[serde(rename = "revoked")]
3171            Revoked,
3172        }
3173        Ok(match __Known::deserialize(deserializer)? {
3174            __Known::Active => Self::Active,
3175            __Known::Retired => Self::Retired,
3176            __Known::Revoked => Self::Revoked,
3177        })
3178    }
3179}
3180
3181/// VolumeView contract value.
3182#[derive(Clone, Debug, PartialEq, Eq)]
3183pub enum VolumeView {
3184    /// A known union arm.
3185    Organization(Box<VolumeViewOrganization>),
3186    /// A known union arm.
3187    Platform(VolumeViewPlatform),
3188    /// An unknown discriminator and its complete wire object.
3189    Unknown { tag: String, value: Value },
3190}
3191impl Serialize for VolumeView {
3192    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3193        match self {
3194            Self::Organization(value) => {
3195                let mut object = serde_json::Map::new();
3196                object.insert("type".into(), Value::String("organization".into()));
3197                object.insert(
3198                    "organization".into(),
3199                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
3200                );
3201                Value::Object(object).serialize(serializer)
3202            }
3203            Self::Platform(value) => {
3204                let mut object = serde_json::Map::new();
3205                object.insert("type".into(), Value::String("platform".into()));
3206                object.insert(
3207                    "platform".into(),
3208                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
3209                );
3210                Value::Object(object).serialize(serializer)
3211            }
3212            Self::Unknown { tag, value } => {
3213                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
3214                    return Err(serde::ser::Error::custom(
3215                        "unknown union discriminator mismatch",
3216                    ));
3217                }
3218                value.serialize(serializer)
3219            }
3220        }
3221    }
3222}
3223impl<'de> Deserialize<'de> for VolumeView {
3224    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3225        let value = Value::deserialize(deserializer)?;
3226        let tag = value
3227            .get("type")
3228            .and_then(Value::as_str)
3229            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
3230        match tag {
3231            "organization" => Ok(Self::Organization(
3232                serde_json::from_value(
3233                    value
3234                        .get("organization")
3235                        .cloned()
3236                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
3237                )
3238                .map_err(serde::de::Error::custom)?,
3239            )),
3240            "platform" => Ok(Self::Platform(
3241                serde_json::from_value(
3242                    value
3243                        .get("platform")
3244                        .cloned()
3245                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
3246                )
3247                .map_err(serde::de::Error::custom)?,
3248            )),
3249            tag => Ok(Self::Unknown {
3250                tag: tag.to_owned(),
3251                value,
3252            }),
3253        }
3254    }
3255}
3256impl<'de> DeserializeStrict<'de> for VolumeView {
3257    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3258        #[derive(Deserialize)]
3259        enum __Tag0 {
3260            #[serde(rename = "organization")]
3261            Value,
3262        }
3263        #[derive(Deserialize)]
3264        #[serde(deny_unknown_fields)]
3265        struct __Arm0 {
3266            #[serde(rename = "type")]
3267            _tag: __Tag0,
3268            #[serde(rename = "organization")]
3269            value: Strict<VolumeViewOrganization>,
3270        }
3271        #[derive(Deserialize)]
3272        enum __Tag1 {
3273            #[serde(rename = "platform")]
3274            Value,
3275        }
3276        #[derive(Deserialize)]
3277        #[serde(deny_unknown_fields)]
3278        struct __Arm1 {
3279            #[serde(rename = "type")]
3280            _tag: __Tag1,
3281            #[serde(rename = "platform")]
3282            value: Strict<VolumeViewPlatform>,
3283        }
3284        #[derive(Deserialize)]
3285        #[serde(untagged)]
3286        enum __Known {
3287            Organization(Box<__Arm0>),
3288            Platform(Box<__Arm1>),
3289        }
3290        Ok(match __Known::deserialize(deserializer)? {
3291            __Known::Organization(arm) => Self::Organization(Box::new(arm.value.0)),
3292            __Known::Platform(arm) => Self::Platform(arm.value.0),
3293        })
3294    }
3295}
3296
3297/// VolumeViewOrganization contract value.
3298#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
3299pub struct VolumeViewOrganization {
3300    /// Contract field details.
3301    #[serde(rename = "details")]
3302    #[serde(default, skip_serializing_if = "Option::is_none")]
3303    pub details: Option<VolumeDetails>,
3304    /// Contract field id.
3305    #[serde(rename = "id")]
3306    pub id: String,
3307    /// Contract field name.
3308    #[serde(rename = "name")]
3309    pub name: String,
3310    /// Contract field orgId.
3311    #[serde(rename = "orgId")]
3312    pub org_id: String,
3313}
3314impl<'de> DeserializeStrict<'de> for VolumeViewOrganization {
3315    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3316        #[derive(Deserialize)]
3317        #[serde(deny_unknown_fields)]
3318        struct __Wire {
3319            #[serde(rename = "details")]
3320            #[serde(default)]
3321            details: Strict<Option<VolumeDetails>>,
3322            #[serde(rename = "id")]
3323            id: Strict<String>,
3324            #[serde(rename = "name")]
3325            name: Strict<String>,
3326            #[serde(rename = "orgId")]
3327            org_id: Strict<String>,
3328        }
3329        let wire = __Wire::deserialize(deserializer)?;
3330        Ok(Self {
3331            details: wire.details.0,
3332            id: wire.id.0,
3333            name: wire.name.0,
3334            org_id: wire.org_id.0,
3335        })
3336    }
3337}
3338
3339/// VolumeViewPlatform contract value.
3340#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
3341pub struct VolumeViewPlatform {
3342    /// Contract field id.
3343    #[serde(rename = "id")]
3344    pub id: String,
3345    /// Contract field provider.
3346    #[serde(rename = "provider")]
3347    pub provider: String,
3348}
3349impl<'de> DeserializeStrict<'de> for VolumeViewPlatform {
3350    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3351        #[derive(Deserialize)]
3352        #[serde(deny_unknown_fields)]
3353        struct __Wire {
3354            #[serde(rename = "id")]
3355            id: Strict<String>,
3356            #[serde(rename = "provider")]
3357            provider: Strict<String>,
3358        }
3359        let wire = __Wire::deserialize(deserializer)?;
3360        Ok(Self {
3361            id: wire.id.0,
3362            provider: wire.provider.0,
3363        })
3364    }
3365}
3366
3367/// Typed errors declared by this service contract.
3368#[derive(Clone, Debug, PartialEq, Eq)]
3369pub enum StorageError {
3370    /// Storage:Conflict.
3371    Conflict { reason: String },
3372    /// Storage:InvalidArgument.
3373    InvalidArgument { reason: String },
3374    /// Storage:LimitReached.
3375    LimitReached { reason: String },
3376    /// Storage:NotFound.
3377    NotFound { resource: String },
3378}
3379impl StorageError {
3380    /// HTTP status for this declared error.
3381    pub fn status(&self) -> u16 {
3382        match self {
3383            Self::Conflict { .. } => 409,
3384            Self::InvalidArgument { .. } => 400,
3385            Self::LimitReached { .. } => 412,
3386            Self::NotFound { .. } => 404,
3387        }
3388    }
3389    /// Serialize only contract-declared error parameters.
3390    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
3391        match self {
3392            Self::Conflict { reason } => {
3393                let mut envelope = ErrorEnvelope::new("CONFLICT", "Storage:Conflict", instance);
3394                envelope
3395                    .parameters
3396                    .insert("reason".into(), reason.to_string());
3397                envelope
3398            }
3399            Self::InvalidArgument { reason } => {
3400                let mut envelope =
3401                    ErrorEnvelope::new("INVALID_ARGUMENT", "Storage:InvalidArgument", instance);
3402                envelope
3403                    .parameters
3404                    .insert("reason".into(), reason.to_string());
3405                envelope
3406            }
3407            Self::LimitReached { reason } => {
3408                let mut envelope =
3409                    ErrorEnvelope::new("FAILED_PRECONDITION", "Storage:LimitReached", instance);
3410                envelope
3411                    .parameters
3412                    .insert("reason".into(), reason.to_string());
3413                envelope
3414            }
3415            Self::NotFound { resource } => {
3416                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Storage:NotFound", instance);
3417                envelope
3418                    .parameters
3419                    .insert("resource".into(), resource.to_string());
3420                envelope
3421            }
3422        }
3423    }
3424    /// Decode a declared error and its typed error parameters.
3425    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
3426        if envelope.error_instance_id.len() != 36
3427            || Uuid::parse_str(&envelope.error_instance_id).is_err()
3428        {
3429            return None;
3430        }
3431        match envelope.error_name.as_str() {
3432            "Storage:Conflict" => {
3433                if envelope.error_code != "CONFLICT" {
3434                    return None;
3435                }
3436                let reason = envelope.parameters.get("reason")?.clone();
3437                Some(Self::Conflict { reason })
3438            }
3439            "Storage:InvalidArgument" => {
3440                if envelope.error_code != "INVALID_ARGUMENT" {
3441                    return None;
3442                }
3443                let reason = envelope.parameters.get("reason")?.clone();
3444                Some(Self::InvalidArgument { reason })
3445            }
3446            "Storage:LimitReached" => {
3447                if envelope.error_code != "FAILED_PRECONDITION" {
3448                    return None;
3449                }
3450                let reason = envelope.parameters.get("reason")?.clone();
3451                Some(Self::LimitReached { reason })
3452            }
3453            "Storage:NotFound" => {
3454                if envelope.error_code != "NOT_FOUND" {
3455                    return None;
3456                }
3457                let resource = envelope.parameters.get("resource")?.clone();
3458                Some(Self::NotFound { resource })
3459            }
3460            _ => None,
3461        }
3462    }
3463}
3464impl Display for StorageError {
3465    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
3466        match self {
3467            Self::Conflict { reason } => write!(formatter, "Storage:Conflict (reason: {})", reason),
3468            Self::InvalidArgument { reason } => {
3469                write!(formatter, "Storage:InvalidArgument (reason: {})", reason)
3470            }
3471            Self::LimitReached { reason } => {
3472                write!(formatter, "Storage:LimitReached (reason: {})", reason)
3473            }
3474            Self::NotFound { resource } => {
3475                write!(formatter, "Storage:NotFound (resource: {})", resource)
3476            }
3477        }
3478    }
3479}
3480impl StdError for StorageError {}
3481impl ServiceError for StorageError {
3482    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
3483        Self::envelope(self, instance)
3484    }
3485    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
3486        Self::decode_envelope(envelope)
3487    }
3488}
3489#[automatically_derived]
3490impl Default for PageRequest {
3491    fn default() -> Self {
3492        Self {
3493            page_size: None,
3494            page_token: None,
3495        }
3496    }
3497}
spiral/api/storage/objects.rs

spiral/api/storage/
objects.rs
