Skip to main content

spiral/api/connections/
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::safelong::SafeLong;
11use spiral_contract::strict::{DeserializeStrict, Strict};
12use uuid::Uuid;
13
14/// AwsAccessKey contract value.
15#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
16pub struct AwsAccessKey {
17    /// Contract field accessKeyId.
18    #[serde(rename = "accessKeyId")]
19    pub access_key_id: String,
20    /// Contract field region.
21    #[serde(rename = "region")]
22    #[serde(default, skip_serializing_if = "Option::is_none")]
23    pub region: Option<String>,
24    /// Contract field secretAccessKey.
25    #[serde(rename = "secretAccessKey")]
26    pub secret_access_key: SecretToken,
27}
28impl<'de> DeserializeStrict<'de> for AwsAccessKey {
29    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
30        #[derive(Deserialize)]
31        #[serde(deny_unknown_fields)]
32        struct __Wire {
33            #[serde(rename = "accessKeyId")]
34            access_key_id: Strict<String>,
35            #[serde(rename = "region")]
36            #[serde(default)]
37            region: Strict<Option<String>>,
38            #[serde(rename = "secretAccessKey")]
39            secret_access_key: Strict<SecretToken>,
40        }
41        let wire = __Wire::deserialize(deserializer)?;
42        Ok(Self {
43            access_key_id: wire.access_key_id.0,
44            region: wire.region.0,
45            secret_access_key: wire.secret_access_key.0,
46        })
47    }
48}
49
50/// AwsAccessKeyConfig contract value.
51#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
52pub struct AwsAccessKeyConfig {
53    /// Contract field accessKeyId.
54    #[serde(rename = "accessKeyId")]
55    pub access_key_id: String,
56    /// Contract field region.
57    #[serde(rename = "region")]
58    #[serde(default, skip_serializing_if = "Option::is_none")]
59    pub region: Option<String>,
60}
61impl<'de> DeserializeStrict<'de> for AwsAccessKeyConfig {
62    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
63        #[derive(Deserialize)]
64        #[serde(deny_unknown_fields)]
65        struct __Wire {
66            #[serde(rename = "accessKeyId")]
67            access_key_id: Strict<String>,
68            #[serde(rename = "region")]
69            #[serde(default)]
70            region: Strict<Option<String>>,
71        }
72        let wire = __Wire::deserialize(deserializer)?;
73        Ok(Self {
74            access_key_id: wire.access_key_id.0,
75            region: wire.region.0,
76        })
77    }
78}
79
80/// AwsOidc contract value.
81#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
82pub struct AwsOidc {
83    /// Contract field region.
84    #[serde(rename = "region")]
85    #[serde(default, skip_serializing_if = "Option::is_none")]
86    pub region: Option<String>,
87    /// Contract field roleArn.
88    #[serde(rename = "roleArn")]
89    pub role_arn: String,
90}
91impl<'de> DeserializeStrict<'de> for AwsOidc {
92    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
93        #[derive(Deserialize)]
94        #[serde(deny_unknown_fields)]
95        struct __Wire {
96            #[serde(rename = "region")]
97            #[serde(default)]
98            region: Strict<Option<String>>,
99            #[serde(rename = "roleArn")]
100            role_arn: Strict<String>,
101        }
102        let wire = __Wire::deserialize(deserializer)?;
103        Ok(Self {
104            region: wire.region.0,
105            role_arn: wire.role_arn.0,
106        })
107    }
108}
109
110/// AwsOidcConfig contract value.
111#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
112pub struct AwsOidcConfig {
113    /// Contract field region.
114    #[serde(rename = "region")]
115    #[serde(default, skip_serializing_if = "Option::is_none")]
116    pub region: Option<String>,
117    /// Contract field roleArn.
118    #[serde(rename = "roleArn")]
119    pub role_arn: String,
120}
121impl<'de> DeserializeStrict<'de> for AwsOidcConfig {
122    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
123        #[derive(Deserialize)]
124        #[serde(deny_unknown_fields)]
125        struct __Wire {
126            #[serde(rename = "region")]
127            #[serde(default)]
128            region: Strict<Option<String>>,
129            #[serde(rename = "roleArn")]
130            role_arn: Strict<String>,
131        }
132        let wire = __Wire::deserialize(deserializer)?;
133        Ok(Self {
134            region: wire.region.0,
135            role_arn: wire.role_arn.0,
136        })
137    }
138}
139
140/// AwsSession contract value.
141#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
142pub struct AwsSession {
143    /// Contract field accessKeyId.
144    #[serde(rename = "accessKeyId")]
145    pub access_key_id: String,
146    /// Contract field endpoint.
147    #[serde(rename = "endpoint")]
148    #[serde(default, skip_serializing_if = "Option::is_none")]
149    pub endpoint: Option<String>,
150    /// Contract field expiresAtMicros.
151    #[serde(rename = "expiresAtMicros")]
152    pub expires_at_micros: SafeLong,
153    /// Contract field region.
154    #[serde(rename = "region")]
155    pub region: String,
156    /// Contract field secretAccessKey.
157    #[serde(rename = "secretAccessKey")]
158    pub secret_access_key: SecretToken,
159    /// Contract field sessionToken.
160    #[serde(rename = "sessionToken")]
161    pub session_token: SecretToken,
162}
163impl<'de> DeserializeStrict<'de> for AwsSession {
164    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
165        #[derive(Deserialize)]
166        #[serde(deny_unknown_fields)]
167        struct __Wire {
168            #[serde(rename = "accessKeyId")]
169            access_key_id: Strict<String>,
170            #[serde(rename = "endpoint")]
171            #[serde(default)]
172            endpoint: Strict<Option<String>>,
173            #[serde(rename = "expiresAtMicros")]
174            expires_at_micros: Strict<SafeLong>,
175            #[serde(rename = "region")]
176            region: Strict<String>,
177            #[serde(rename = "secretAccessKey")]
178            secret_access_key: Strict<SecretToken>,
179            #[serde(rename = "sessionToken")]
180            session_token: Strict<SecretToken>,
181        }
182        let wire = __Wire::deserialize(deserializer)?;
183        Ok(Self {
184            access_key_id: wire.access_key_id.0,
185            endpoint: wire.endpoint.0,
186            expires_at_micros: wire.expires_at_micros.0,
187            region: wire.region.0,
188            secret_access_key: wire.secret_access_key.0,
189            session_token: wire.session_token.0,
190        })
191    }
192}
193
194/// CephAccessKey contract value.
195#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
196pub struct CephAccessKey {
197    /// Contract field accessKeyId.
198    #[serde(rename = "accessKeyId")]
199    pub access_key_id: String,
200    /// Contract field endpoint.
201    #[serde(rename = "endpoint")]
202    pub endpoint: String,
203    /// Contract field region.
204    #[serde(rename = "region")]
205    #[serde(default, skip_serializing_if = "Option::is_none")]
206    pub region: Option<String>,
207    /// Contract field roleArn.
208    #[serde(rename = "roleArn")]
209    pub role_arn: String,
210    /// Contract field secretAccessKey.
211    #[serde(rename = "secretAccessKey")]
212    pub secret_access_key: SecretToken,
213}
214impl<'de> DeserializeStrict<'de> for CephAccessKey {
215    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
216        #[derive(Deserialize)]
217        #[serde(deny_unknown_fields)]
218        struct __Wire {
219            #[serde(rename = "accessKeyId")]
220            access_key_id: Strict<String>,
221            #[serde(rename = "endpoint")]
222            endpoint: Strict<String>,
223            #[serde(rename = "region")]
224            #[serde(default)]
225            region: Strict<Option<String>>,
226            #[serde(rename = "roleArn")]
227            role_arn: Strict<String>,
228            #[serde(rename = "secretAccessKey")]
229            secret_access_key: Strict<SecretToken>,
230        }
231        let wire = __Wire::deserialize(deserializer)?;
232        Ok(Self {
233            access_key_id: wire.access_key_id.0,
234            endpoint: wire.endpoint.0,
235            region: wire.region.0,
236            role_arn: wire.role_arn.0,
237            secret_access_key: wire.secret_access_key.0,
238        })
239    }
240}
241
242/// CephAccessKeyConfig contract value.
243#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
244pub struct CephAccessKeyConfig {
245    /// Contract field accessKeyId.
246    #[serde(rename = "accessKeyId")]
247    pub access_key_id: String,
248    /// Contract field endpoint.
249    #[serde(rename = "endpoint")]
250    pub endpoint: String,
251    /// Contract field region.
252    #[serde(rename = "region")]
253    #[serde(default, skip_serializing_if = "Option::is_none")]
254    pub region: Option<String>,
255    /// Contract field roleArn.
256    #[serde(rename = "roleArn")]
257    pub role_arn: String,
258}
259impl<'de> DeserializeStrict<'de> for CephAccessKeyConfig {
260    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
261        #[derive(Deserialize)]
262        #[serde(deny_unknown_fields)]
263        struct __Wire {
264            #[serde(rename = "accessKeyId")]
265            access_key_id: Strict<String>,
266            #[serde(rename = "endpoint")]
267            endpoint: Strict<String>,
268            #[serde(rename = "region")]
269            #[serde(default)]
270            region: Strict<Option<String>>,
271            #[serde(rename = "roleArn")]
272            role_arn: Strict<String>,
273        }
274        let wire = __Wire::deserialize(deserializer)?;
275        Ok(Self {
276            access_key_id: wire.access_key_id.0,
277            endpoint: wire.endpoint.0,
278            region: wire.region.0,
279            role_arn: wire.role_arn.0,
280        })
281    }
282}
283
284/// CephOidc contract value.
285#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
286pub struct CephOidc {
287    /// Contract field endpoint.
288    #[serde(rename = "endpoint")]
289    pub endpoint: String,
290    /// Contract field region.
291    #[serde(rename = "region")]
292    #[serde(default, skip_serializing_if = "Option::is_none")]
293    pub region: Option<String>,
294    /// Contract field roleArn.
295    #[serde(rename = "roleArn")]
296    pub role_arn: String,
297}
298impl<'de> DeserializeStrict<'de> for CephOidc {
299    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
300        #[derive(Deserialize)]
301        #[serde(deny_unknown_fields)]
302        struct __Wire {
303            #[serde(rename = "endpoint")]
304            endpoint: Strict<String>,
305            #[serde(rename = "region")]
306            #[serde(default)]
307            region: Strict<Option<String>>,
308            #[serde(rename = "roleArn")]
309            role_arn: Strict<String>,
310        }
311        let wire = __Wire::deserialize(deserializer)?;
312        Ok(Self {
313            endpoint: wire.endpoint.0,
314            region: wire.region.0,
315            role_arn: wire.role_arn.0,
316        })
317    }
318}
319
320/// CephOidcConfig contract value.
321#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
322pub struct CephOidcConfig {
323    /// Contract field endpoint.
324    #[serde(rename = "endpoint")]
325    pub endpoint: String,
326    /// Contract field region.
327    #[serde(rename = "region")]
328    #[serde(default, skip_serializing_if = "Option::is_none")]
329    pub region: Option<String>,
330    /// Contract field roleArn.
331    #[serde(rename = "roleArn")]
332    pub role_arn: String,
333}
334impl<'de> DeserializeStrict<'de> for CephOidcConfig {
335    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
336        #[derive(Deserialize)]
337        #[serde(deny_unknown_fields)]
338        struct __Wire {
339            #[serde(rename = "endpoint")]
340            endpoint: Strict<String>,
341            #[serde(rename = "region")]
342            #[serde(default)]
343            region: Strict<Option<String>>,
344            #[serde(rename = "roleArn")]
345            role_arn: Strict<String>,
346        }
347        let wire = __Wire::deserialize(deserializer)?;
348        Ok(Self {
349            endpoint: wire.endpoint.0,
350            region: wire.region.0,
351            role_arn: wire.role_arn.0,
352        })
353    }
354}
355
356/// Connection contract value.
357#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
358pub struct Connection {
359    /// Contract field allowedAccess.
360    #[serde(rename = "allowedAccess")]
361    pub allowed_access: ConnectionAccess,
362    /// Contract field connectionId.
363    #[serde(rename = "connectionId")]
364    pub connection_id: Uuid,
365    /// Contract field createdAtMicros.
366    #[serde(rename = "createdAtMicros")]
367    pub created_at_micros: SafeLong,
368    /// Contract field createdBy.
369    #[serde(rename = "createdBy")]
370    pub created_by: String,
371    /// Contract field credential.
372    #[serde(rename = "credential")]
373    pub credential: CredentialConfig,
374    /// Contract field credentialUpdatedAtMicros.
375    #[serde(rename = "credentialUpdatedAtMicros")]
376    pub credential_updated_at_micros: SafeLong,
377    /// Contract field description.
378    #[serde(rename = "description")]
379    #[serde(default, skip_serializing_if = "Option::is_none")]
380    pub description: Option<String>,
381    /// Contract field dropped.
382    #[serde(rename = "dropped")]
383    #[serde(default, skip_serializing_if = "Option::is_none")]
384    pub dropped: Option<DropRecord>,
385    /// Contract field identity.
386    #[serde(rename = "identity")]
387    #[serde(default, skip_serializing_if = "Option::is_none")]
388    pub identity: Option<ConnectionIdentity>,
389    /// Contract field projectId.
390    #[serde(rename = "projectId")]
391    pub project_id: String,
392    /// Contract field uri.
393    #[serde(rename = "uri")]
394    pub uri: String,
395}
396impl<'de> DeserializeStrict<'de> for Connection {
397    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
398        #[derive(Deserialize)]
399        #[serde(deny_unknown_fields)]
400        struct __Wire {
401            #[serde(rename = "allowedAccess")]
402            allowed_access: Strict<ConnectionAccess>,
403            #[serde(rename = "connectionId")]
404            connection_id: Strict<Uuid>,
405            #[serde(rename = "createdAtMicros")]
406            created_at_micros: Strict<SafeLong>,
407            #[serde(rename = "createdBy")]
408            created_by: Strict<String>,
409            #[serde(rename = "credential")]
410            credential: Strict<CredentialConfig>,
411            #[serde(rename = "credentialUpdatedAtMicros")]
412            credential_updated_at_micros: Strict<SafeLong>,
413            #[serde(rename = "description")]
414            #[serde(default)]
415            description: Strict<Option<String>>,
416            #[serde(rename = "dropped")]
417            #[serde(default)]
418            dropped: Strict<Option<DropRecord>>,
419            #[serde(rename = "identity")]
420            #[serde(default)]
421            identity: Strict<Option<ConnectionIdentity>>,
422            #[serde(rename = "projectId")]
423            project_id: Strict<String>,
424            #[serde(rename = "uri")]
425            uri: Strict<String>,
426        }
427        let wire = __Wire::deserialize(deserializer)?;
428        Ok(Self {
429            allowed_access: wire.allowed_access.0,
430            connection_id: wire.connection_id.0,
431            created_at_micros: wire.created_at_micros.0,
432            created_by: wire.created_by.0,
433            credential: wire.credential.0,
434            credential_updated_at_micros: wire.credential_updated_at_micros.0,
435            description: wire.description.0,
436            dropped: wire.dropped.0,
437            identity: wire.identity.0,
438            project_id: wire.project_id.0,
439            uri: wire.uri.0,
440        })
441    }
442}
443
444/// ConnectionAccess contract value.
445#[derive(Clone, Debug, PartialEq, Eq)]
446pub enum ConnectionAccess {
447    /// A known contract value.
448    Read,
449    /// A known contract value.
450    Write,
451    /// A value introduced by a newer server.
452    Unknown(String),
453}
454impl Serialize for ConnectionAccess {
455    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
456        serializer.serialize_str(match self {
457            Self::Read => "read",
458            Self::Write => "write",
459            Self::Unknown(value) => value,
460        })
461    }
462}
463impl<'de> Deserialize<'de> for ConnectionAccess {
464    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
465        Ok(match String::deserialize(deserializer)?.as_str() {
466            "read" => Self::Read,
467            "write" => Self::Write,
468            value => Self::Unknown(value.to_owned()),
469        })
470    }
471}
472impl<'de> DeserializeStrict<'de> for ConnectionAccess {
473    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
474        #[derive(Deserialize)]
475        enum __Known {
476            #[serde(rename = "read")]
477            Read,
478            #[serde(rename = "write")]
479            Write,
480        }
481        Ok(match __Known::deserialize(deserializer)? {
482            __Known::Read => Self::Read,
483            __Known::Write => Self::Write,
484        })
485    }
486}
487
488/// ConnectionIdentity contract value.
489#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
490pub struct ConnectionIdentity {
491    /// Contract field audience.
492    #[serde(rename = "audience")]
493    pub audience: String,
494    /// Contract field issuer.
495    #[serde(rename = "issuer")]
496    pub issuer: String,
497    /// Contract field subject.
498    #[serde(rename = "subject")]
499    pub subject: String,
500    /// Contract field trustPolicy.
501    #[serde(rename = "trustPolicy")]
502    pub trust_policy: String,
503}
504impl<'de> DeserializeStrict<'de> for ConnectionIdentity {
505    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
506        #[derive(Deserialize)]
507        #[serde(deny_unknown_fields)]
508        struct __Wire {
509            #[serde(rename = "audience")]
510            audience: Strict<String>,
511            #[serde(rename = "issuer")]
512            issuer: Strict<String>,
513            #[serde(rename = "subject")]
514            subject: Strict<String>,
515            #[serde(rename = "trustPolicy")]
516            trust_policy: Strict<String>,
517        }
518        let wire = __Wire::deserialize(deserializer)?;
519        Ok(Self {
520            audience: wire.audience.0,
521            issuer: wire.issuer.0,
522            subject: wire.subject.0,
523            trust_policy: wire.trust_policy.0,
524        })
525    }
526}
527
528/// ConnectionResponse contract value.
529#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
530pub struct ConnectionResponse {
531    /// Contract field connection.
532    #[serde(rename = "connection")]
533    pub connection: Connection,
534}
535impl<'de> DeserializeStrict<'de> for ConnectionResponse {
536    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
537        #[derive(Deserialize)]
538        #[serde(deny_unknown_fields)]
539        struct __Wire {
540            #[serde(rename = "connection")]
541            connection: Strict<Connection>,
542        }
543        let wire = __Wire::deserialize(deserializer)?;
544        Ok(Self {
545            connection: wire.connection.0,
546        })
547    }
548}
549
550/// CreateConnectionRequest contract value.
551#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
552pub struct CreateConnectionRequest {
553    /// Contract field credential.
554    #[serde(rename = "credential")]
555    pub credential: Credential,
556    /// Contract field description.
557    #[serde(rename = "description")]
558    #[serde(default, skip_serializing_if = "Option::is_none")]
559    pub description: Option<String>,
560    /// Contract field projectId.
561    #[serde(rename = "projectId")]
562    pub project_id: String,
563    /// Contract field uri.
564    #[serde(rename = "uri")]
565    pub uri: String,
566}
567impl<'de> DeserializeStrict<'de> for CreateConnectionRequest {
568    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
569        #[derive(Deserialize)]
570        #[serde(deny_unknown_fields)]
571        struct __Wire {
572            #[serde(rename = "credential")]
573            credential: Strict<Credential>,
574            #[serde(rename = "description")]
575            #[serde(default)]
576            description: Strict<Option<String>>,
577            #[serde(rename = "projectId")]
578            project_id: Strict<String>,
579            #[serde(rename = "uri")]
580            uri: Strict<String>,
581        }
582        let wire = __Wire::deserialize(deserializer)?;
583        Ok(Self {
584            credential: wire.credential.0,
585            description: wire.description.0,
586            project_id: wire.project_id.0,
587            uri: wire.uri.0,
588        })
589    }
590}
591
592/// CreateConnectionResponse contract value.
593#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
594pub struct CreateConnectionResponse {
595    /// Contract field connection.
596    #[serde(rename = "connection")]
597    pub connection: Connection,
598    /// Contract field versionId.
599    #[serde(rename = "versionId")]
600    pub version_id: Uuid,
601}
602impl<'de> DeserializeStrict<'de> for CreateConnectionResponse {
603    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
604        #[derive(Deserialize)]
605        #[serde(deny_unknown_fields)]
606        struct __Wire {
607            #[serde(rename = "connection")]
608            connection: Strict<Connection>,
609            #[serde(rename = "versionId")]
610            version_id: Strict<Uuid>,
611        }
612        let wire = __Wire::deserialize(deserializer)?;
613        Ok(Self {
614            connection: wire.connection.0,
615            version_id: wire.version_id.0,
616        })
617    }
618}
619
620/// A complete replacement credential, including every required secret. OIDC credentials contain no
621/// stored secret.
622#[derive(Clone, Debug, PartialEq, Eq)]
623pub enum Credential {
624    /// A known union arm.
625    AwsAccessKey(AwsAccessKey),
626    /// A known union arm.
627    AwsOidc(AwsOidc),
628    /// A known union arm.
629    CephAccessKey(CephAccessKey),
630    /// A known union arm.
631    CephOidc(CephOidc),
632    /// A known union arm.
633    GcsOidc(GcsOidc),
634    /// A known union arm.
635    GcsServiceAccountKey(GcsServiceAccountKey),
636    /// A known union arm.
637    HuggingFaceToken(HuggingFaceCredential),
638    /// A known union arm.
639    MinioAccessKey(S3AccessKey),
640    /// A known union arm.
641    R2AccessKey(R2AccessKey),
642    /// A known union arm.
643    RustfsAccessKey(S3AccessKey),
644    /// A known union arm.
645    S3LikeAccessKey(S3AccessKey),
646    /// An unknown discriminator and its complete wire object.
647    Unknown { tag: String, value: Value },
648}
649impl Serialize for Credential {
650    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
651        match self {
652            Self::AwsAccessKey(value) => {
653                let mut object = serde_json::Map::new();
654                object.insert("type".into(), Value::String("awsAccessKey".into()));
655                object.insert(
656                    "awsAccessKey".into(),
657                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
658                );
659                Value::Object(object).serialize(serializer)
660            }
661            Self::AwsOidc(value) => {
662                let mut object = serde_json::Map::new();
663                object.insert("type".into(), Value::String("awsOidc".into()));
664                object.insert(
665                    "awsOidc".into(),
666                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
667                );
668                Value::Object(object).serialize(serializer)
669            }
670            Self::CephAccessKey(value) => {
671                let mut object = serde_json::Map::new();
672                object.insert("type".into(), Value::String("cephAccessKey".into()));
673                object.insert(
674                    "cephAccessKey".into(),
675                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
676                );
677                Value::Object(object).serialize(serializer)
678            }
679            Self::CephOidc(value) => {
680                let mut object = serde_json::Map::new();
681                object.insert("type".into(), Value::String("cephOidc".into()));
682                object.insert(
683                    "cephOidc".into(),
684                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
685                );
686                Value::Object(object).serialize(serializer)
687            }
688            Self::GcsOidc(value) => {
689                let mut object = serde_json::Map::new();
690                object.insert("type".into(), Value::String("gcsOidc".into()));
691                object.insert(
692                    "gcsOidc".into(),
693                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
694                );
695                Value::Object(object).serialize(serializer)
696            }
697            Self::GcsServiceAccountKey(value) => {
698                let mut object = serde_json::Map::new();
699                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
700                object.insert(
701                    "gcsServiceAccountKey".into(),
702                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
703                );
704                Value::Object(object).serialize(serializer)
705            }
706            Self::HuggingFaceToken(value) => {
707                let mut object = serde_json::Map::new();
708                object.insert("type".into(), Value::String("huggingFaceToken".into()));
709                object.insert(
710                    "huggingFaceToken".into(),
711                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
712                );
713                Value::Object(object).serialize(serializer)
714            }
715            Self::MinioAccessKey(value) => {
716                let mut object = serde_json::Map::new();
717                object.insert("type".into(), Value::String("minioAccessKey".into()));
718                object.insert(
719                    "minioAccessKey".into(),
720                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
721                );
722                Value::Object(object).serialize(serializer)
723            }
724            Self::R2AccessKey(value) => {
725                let mut object = serde_json::Map::new();
726                object.insert("type".into(), Value::String("r2AccessKey".into()));
727                object.insert(
728                    "r2AccessKey".into(),
729                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
730                );
731                Value::Object(object).serialize(serializer)
732            }
733            Self::RustfsAccessKey(value) => {
734                let mut object = serde_json::Map::new();
735                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
736                object.insert(
737                    "rustfsAccessKey".into(),
738                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
739                );
740                Value::Object(object).serialize(serializer)
741            }
742            Self::S3LikeAccessKey(value) => {
743                let mut object = serde_json::Map::new();
744                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
745                object.insert(
746                    "s3LikeAccessKey".into(),
747                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
748                );
749                Value::Object(object).serialize(serializer)
750            }
751            Self::Unknown { tag, value } => {
752                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
753                    return Err(serde::ser::Error::custom(
754                        "unknown union discriminator mismatch",
755                    ));
756                }
757                value.serialize(serializer)
758            }
759        }
760    }
761}
762impl<'de> Deserialize<'de> for Credential {
763    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
764        let value = Value::deserialize(deserializer)?;
765        let tag = value
766            .get("type")
767            .and_then(Value::as_str)
768            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
769        match tag {
770            "awsAccessKey" => Ok(Self::AwsAccessKey(
771                serde_json::from_value(
772                    value
773                        .get("awsAccessKey")
774                        .cloned()
775                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
776                )
777                .map_err(serde::de::Error::custom)?,
778            )),
779            "awsOidc" => Ok(Self::AwsOidc(
780                serde_json::from_value(
781                    value
782                        .get("awsOidc")
783                        .cloned()
784                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
785                )
786                .map_err(serde::de::Error::custom)?,
787            )),
788            "cephAccessKey" => Ok(Self::CephAccessKey(
789                serde_json::from_value(
790                    value
791                        .get("cephAccessKey")
792                        .cloned()
793                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
794                )
795                .map_err(serde::de::Error::custom)?,
796            )),
797            "cephOidc" => Ok(Self::CephOidc(
798                serde_json::from_value(
799                    value
800                        .get("cephOidc")
801                        .cloned()
802                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
803                )
804                .map_err(serde::de::Error::custom)?,
805            )),
806            "gcsOidc" => Ok(Self::GcsOidc(
807                serde_json::from_value(
808                    value
809                        .get("gcsOidc")
810                        .cloned()
811                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
812                )
813                .map_err(serde::de::Error::custom)?,
814            )),
815            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
816                serde_json::from_value(
817                    value
818                        .get("gcsServiceAccountKey")
819                        .cloned()
820                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
821                )
822                .map_err(serde::de::Error::custom)?,
823            )),
824            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
825                serde_json::from_value(
826                    value
827                        .get("huggingFaceToken")
828                        .cloned()
829                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
830                )
831                .map_err(serde::de::Error::custom)?,
832            )),
833            "minioAccessKey" => Ok(Self::MinioAccessKey(
834                serde_json::from_value(
835                    value
836                        .get("minioAccessKey")
837                        .cloned()
838                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
839                )
840                .map_err(serde::de::Error::custom)?,
841            )),
842            "r2AccessKey" => Ok(Self::R2AccessKey(
843                serde_json::from_value(
844                    value
845                        .get("r2AccessKey")
846                        .cloned()
847                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
848                )
849                .map_err(serde::de::Error::custom)?,
850            )),
851            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
852                serde_json::from_value(
853                    value
854                        .get("rustfsAccessKey")
855                        .cloned()
856                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
857                )
858                .map_err(serde::de::Error::custom)?,
859            )),
860            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
861                serde_json::from_value(
862                    value
863                        .get("s3LikeAccessKey")
864                        .cloned()
865                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
866                )
867                .map_err(serde::de::Error::custom)?,
868            )),
869            tag => Ok(Self::Unknown {
870                tag: tag.to_owned(),
871                value,
872            }),
873        }
874    }
875}
876impl<'de> DeserializeStrict<'de> for Credential {
877    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
878        #[derive(Deserialize)]
879        enum __Tag0 {
880            #[serde(rename = "awsAccessKey")]
881            Value,
882        }
883        #[derive(Deserialize)]
884        #[serde(deny_unknown_fields)]
885        struct __Arm0 {
886            #[serde(rename = "type")]
887            _tag: __Tag0,
888            #[serde(rename = "awsAccessKey")]
889            value: Strict<AwsAccessKey>,
890        }
891        #[derive(Deserialize)]
892        enum __Tag1 {
893            #[serde(rename = "awsOidc")]
894            Value,
895        }
896        #[derive(Deserialize)]
897        #[serde(deny_unknown_fields)]
898        struct __Arm1 {
899            #[serde(rename = "type")]
900            _tag: __Tag1,
901            #[serde(rename = "awsOidc")]
902            value: Strict<AwsOidc>,
903        }
904        #[derive(Deserialize)]
905        enum __Tag2 {
906            #[serde(rename = "cephAccessKey")]
907            Value,
908        }
909        #[derive(Deserialize)]
910        #[serde(deny_unknown_fields)]
911        struct __Arm2 {
912            #[serde(rename = "type")]
913            _tag: __Tag2,
914            #[serde(rename = "cephAccessKey")]
915            value: Strict<CephAccessKey>,
916        }
917        #[derive(Deserialize)]
918        enum __Tag3 {
919            #[serde(rename = "cephOidc")]
920            Value,
921        }
922        #[derive(Deserialize)]
923        #[serde(deny_unknown_fields)]
924        struct __Arm3 {
925            #[serde(rename = "type")]
926            _tag: __Tag3,
927            #[serde(rename = "cephOidc")]
928            value: Strict<CephOidc>,
929        }
930        #[derive(Deserialize)]
931        enum __Tag4 {
932            #[serde(rename = "gcsOidc")]
933            Value,
934        }
935        #[derive(Deserialize)]
936        #[serde(deny_unknown_fields)]
937        struct __Arm4 {
938            #[serde(rename = "type")]
939            _tag: __Tag4,
940            #[serde(rename = "gcsOidc")]
941            value: Strict<GcsOidc>,
942        }
943        #[derive(Deserialize)]
944        enum __Tag5 {
945            #[serde(rename = "gcsServiceAccountKey")]
946            Value,
947        }
948        #[derive(Deserialize)]
949        #[serde(deny_unknown_fields)]
950        struct __Arm5 {
951            #[serde(rename = "type")]
952            _tag: __Tag5,
953            #[serde(rename = "gcsServiceAccountKey")]
954            value: Strict<GcsServiceAccountKey>,
955        }
956        #[derive(Deserialize)]
957        enum __Tag6 {
958            #[serde(rename = "huggingFaceToken")]
959            Value,
960        }
961        #[derive(Deserialize)]
962        #[serde(deny_unknown_fields)]
963        struct __Arm6 {
964            #[serde(rename = "type")]
965            _tag: __Tag6,
966            #[serde(rename = "huggingFaceToken")]
967            value: Strict<HuggingFaceCredential>,
968        }
969        #[derive(Deserialize)]
970        enum __Tag7 {
971            #[serde(rename = "minioAccessKey")]
972            Value,
973        }
974        #[derive(Deserialize)]
975        #[serde(deny_unknown_fields)]
976        struct __Arm7 {
977            #[serde(rename = "type")]
978            _tag: __Tag7,
979            #[serde(rename = "minioAccessKey")]
980            value: Strict<S3AccessKey>,
981        }
982        #[derive(Deserialize)]
983        enum __Tag8 {
984            #[serde(rename = "r2AccessKey")]
985            Value,
986        }
987        #[derive(Deserialize)]
988        #[serde(deny_unknown_fields)]
989        struct __Arm8 {
990            #[serde(rename = "type")]
991            _tag: __Tag8,
992            #[serde(rename = "r2AccessKey")]
993            value: Strict<R2AccessKey>,
994        }
995        #[derive(Deserialize)]
996        enum __Tag9 {
997            #[serde(rename = "rustfsAccessKey")]
998            Value,
999        }
1000        #[derive(Deserialize)]
1001        #[serde(deny_unknown_fields)]
1002        struct __Arm9 {
1003            #[serde(rename = "type")]
1004            _tag: __Tag9,
1005            #[serde(rename = "rustfsAccessKey")]
1006            value: Strict<S3AccessKey>,
1007        }
1008        #[derive(Deserialize)]
1009        enum __Tag10 {
1010            #[serde(rename = "s3LikeAccessKey")]
1011            Value,
1012        }
1013        #[derive(Deserialize)]
1014        #[serde(deny_unknown_fields)]
1015        struct __Arm10 {
1016            #[serde(rename = "type")]
1017            _tag: __Tag10,
1018            #[serde(rename = "s3LikeAccessKey")]
1019            value: Strict<S3AccessKey>,
1020        }
1021        #[derive(Deserialize)]
1022        #[serde(untagged)]
1023        enum __Known {
1024            AwsAccessKey(Box<__Arm0>),
1025            AwsOidc(Box<__Arm1>),
1026            CephAccessKey(Box<__Arm2>),
1027            CephOidc(Box<__Arm3>),
1028            GcsOidc(Box<__Arm4>),
1029            GcsServiceAccountKey(Box<__Arm5>),
1030            HuggingFaceToken(Box<__Arm6>),
1031            MinioAccessKey(Box<__Arm7>),
1032            R2AccessKey(Box<__Arm8>),
1033            RustfsAccessKey(Box<__Arm9>),
1034            S3LikeAccessKey(Box<__Arm10>),
1035        }
1036        Ok(match __Known::deserialize(deserializer)? {
1037            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
1038            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
1039            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
1040            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
1041            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
1042            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
1043            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
1044            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
1045            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
1046            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
1047            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
1048        })
1049    }
1050}
1051
1052/// The credential configuration returned by reads. It has no fields for stored secrets.
1053#[derive(Clone, Debug, PartialEq, Eq)]
1054pub enum CredentialConfig {
1055    /// A known union arm.
1056    AwsAccessKey(AwsAccessKeyConfig),
1057    /// A known union arm.
1058    AwsOidc(AwsOidcConfig),
1059    /// A known union arm.
1060    CephAccessKey(CephAccessKeyConfig),
1061    /// A known union arm.
1062    CephOidc(CephOidcConfig),
1063    /// A known union arm.
1064    GcsOidc(GcsOidcConfig),
1065    /// A known union arm.
1066    GcsServiceAccountKey(GcsServiceAccountKeyConfig),
1067    /// A known union arm.
1068    HuggingFaceToken(HuggingFaceCredentialConfig),
1069    /// A known union arm.
1070    MinioAccessKey(S3AccessKeyConfig),
1071    /// A known union arm.
1072    R2AccessKey(R2AccessKeyConfig),
1073    /// A known union arm.
1074    RustfsAccessKey(S3AccessKeyConfig),
1075    /// A known union arm.
1076    S3LikeAccessKey(S3AccessKeyConfig),
1077    /// An unknown discriminator and its complete wire object.
1078    Unknown { tag: String, value: Value },
1079}
1080impl Serialize for CredentialConfig {
1081    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1082        match self {
1083            Self::AwsAccessKey(value) => {
1084                let mut object = serde_json::Map::new();
1085                object.insert("type".into(), Value::String("awsAccessKey".into()));
1086                object.insert(
1087                    "awsAccessKey".into(),
1088                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1089                );
1090                Value::Object(object).serialize(serializer)
1091            }
1092            Self::AwsOidc(value) => {
1093                let mut object = serde_json::Map::new();
1094                object.insert("type".into(), Value::String("awsOidc".into()));
1095                object.insert(
1096                    "awsOidc".into(),
1097                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1098                );
1099                Value::Object(object).serialize(serializer)
1100            }
1101            Self::CephAccessKey(value) => {
1102                let mut object = serde_json::Map::new();
1103                object.insert("type".into(), Value::String("cephAccessKey".into()));
1104                object.insert(
1105                    "cephAccessKey".into(),
1106                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1107                );
1108                Value::Object(object).serialize(serializer)
1109            }
1110            Self::CephOidc(value) => {
1111                let mut object = serde_json::Map::new();
1112                object.insert("type".into(), Value::String("cephOidc".into()));
1113                object.insert(
1114                    "cephOidc".into(),
1115                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1116                );
1117                Value::Object(object).serialize(serializer)
1118            }
1119            Self::GcsOidc(value) => {
1120                let mut object = serde_json::Map::new();
1121                object.insert("type".into(), Value::String("gcsOidc".into()));
1122                object.insert(
1123                    "gcsOidc".into(),
1124                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1125                );
1126                Value::Object(object).serialize(serializer)
1127            }
1128            Self::GcsServiceAccountKey(value) => {
1129                let mut object = serde_json::Map::new();
1130                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
1131                object.insert(
1132                    "gcsServiceAccountKey".into(),
1133                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1134                );
1135                Value::Object(object).serialize(serializer)
1136            }
1137            Self::HuggingFaceToken(value) => {
1138                let mut object = serde_json::Map::new();
1139                object.insert("type".into(), Value::String("huggingFaceToken".into()));
1140                object.insert(
1141                    "huggingFaceToken".into(),
1142                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1143                );
1144                Value::Object(object).serialize(serializer)
1145            }
1146            Self::MinioAccessKey(value) => {
1147                let mut object = serde_json::Map::new();
1148                object.insert("type".into(), Value::String("minioAccessKey".into()));
1149                object.insert(
1150                    "minioAccessKey".into(),
1151                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1152                );
1153                Value::Object(object).serialize(serializer)
1154            }
1155            Self::R2AccessKey(value) => {
1156                let mut object = serde_json::Map::new();
1157                object.insert("type".into(), Value::String("r2AccessKey".into()));
1158                object.insert(
1159                    "r2AccessKey".into(),
1160                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1161                );
1162                Value::Object(object).serialize(serializer)
1163            }
1164            Self::RustfsAccessKey(value) => {
1165                let mut object = serde_json::Map::new();
1166                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
1167                object.insert(
1168                    "rustfsAccessKey".into(),
1169                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1170                );
1171                Value::Object(object).serialize(serializer)
1172            }
1173            Self::S3LikeAccessKey(value) => {
1174                let mut object = serde_json::Map::new();
1175                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
1176                object.insert(
1177                    "s3LikeAccessKey".into(),
1178                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
1179                );
1180                Value::Object(object).serialize(serializer)
1181            }
1182            Self::Unknown { tag, value } => {
1183                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
1184                    return Err(serde::ser::Error::custom(
1185                        "unknown union discriminator mismatch",
1186                    ));
1187                }
1188                value.serialize(serializer)
1189            }
1190        }
1191    }
1192}
1193impl<'de> Deserialize<'de> for CredentialConfig {
1194    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1195        let value = Value::deserialize(deserializer)?;
1196        let tag = value
1197            .get("type")
1198            .and_then(Value::as_str)
1199            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
1200        match tag {
1201            "awsAccessKey" => Ok(Self::AwsAccessKey(
1202                serde_json::from_value(
1203                    value
1204                        .get("awsAccessKey")
1205                        .cloned()
1206                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1207                )
1208                .map_err(serde::de::Error::custom)?,
1209            )),
1210            "awsOidc" => Ok(Self::AwsOidc(
1211                serde_json::from_value(
1212                    value
1213                        .get("awsOidc")
1214                        .cloned()
1215                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1216                )
1217                .map_err(serde::de::Error::custom)?,
1218            )),
1219            "cephAccessKey" => Ok(Self::CephAccessKey(
1220                serde_json::from_value(
1221                    value
1222                        .get("cephAccessKey")
1223                        .cloned()
1224                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1225                )
1226                .map_err(serde::de::Error::custom)?,
1227            )),
1228            "cephOidc" => Ok(Self::CephOidc(
1229                serde_json::from_value(
1230                    value
1231                        .get("cephOidc")
1232                        .cloned()
1233                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1234                )
1235                .map_err(serde::de::Error::custom)?,
1236            )),
1237            "gcsOidc" => Ok(Self::GcsOidc(
1238                serde_json::from_value(
1239                    value
1240                        .get("gcsOidc")
1241                        .cloned()
1242                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1243                )
1244                .map_err(serde::de::Error::custom)?,
1245            )),
1246            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
1247                serde_json::from_value(
1248                    value
1249                        .get("gcsServiceAccountKey")
1250                        .cloned()
1251                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1252                )
1253                .map_err(serde::de::Error::custom)?,
1254            )),
1255            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
1256                serde_json::from_value(
1257                    value
1258                        .get("huggingFaceToken")
1259                        .cloned()
1260                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1261                )
1262                .map_err(serde::de::Error::custom)?,
1263            )),
1264            "minioAccessKey" => Ok(Self::MinioAccessKey(
1265                serde_json::from_value(
1266                    value
1267                        .get("minioAccessKey")
1268                        .cloned()
1269                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1270                )
1271                .map_err(serde::de::Error::custom)?,
1272            )),
1273            "r2AccessKey" => Ok(Self::R2AccessKey(
1274                serde_json::from_value(
1275                    value
1276                        .get("r2AccessKey")
1277                        .cloned()
1278                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1279                )
1280                .map_err(serde::de::Error::custom)?,
1281            )),
1282            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
1283                serde_json::from_value(
1284                    value
1285                        .get("rustfsAccessKey")
1286                        .cloned()
1287                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1288                )
1289                .map_err(serde::de::Error::custom)?,
1290            )),
1291            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
1292                serde_json::from_value(
1293                    value
1294                        .get("s3LikeAccessKey")
1295                        .cloned()
1296                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
1297                )
1298                .map_err(serde::de::Error::custom)?,
1299            )),
1300            tag => Ok(Self::Unknown {
1301                tag: tag.to_owned(),
1302                value,
1303            }),
1304        }
1305    }
1306}
1307impl<'de> DeserializeStrict<'de> for CredentialConfig {
1308    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1309        #[derive(Deserialize)]
1310        enum __Tag0 {
1311            #[serde(rename = "awsAccessKey")]
1312            Value,
1313        }
1314        #[derive(Deserialize)]
1315        #[serde(deny_unknown_fields)]
1316        struct __Arm0 {
1317            #[serde(rename = "type")]
1318            _tag: __Tag0,
1319            #[serde(rename = "awsAccessKey")]
1320            value: Strict<AwsAccessKeyConfig>,
1321        }
1322        #[derive(Deserialize)]
1323        enum __Tag1 {
1324            #[serde(rename = "awsOidc")]
1325            Value,
1326        }
1327        #[derive(Deserialize)]
1328        #[serde(deny_unknown_fields)]
1329        struct __Arm1 {
1330            #[serde(rename = "type")]
1331            _tag: __Tag1,
1332            #[serde(rename = "awsOidc")]
1333            value: Strict<AwsOidcConfig>,
1334        }
1335        #[derive(Deserialize)]
1336        enum __Tag2 {
1337            #[serde(rename = "cephAccessKey")]
1338            Value,
1339        }
1340        #[derive(Deserialize)]
1341        #[serde(deny_unknown_fields)]
1342        struct __Arm2 {
1343            #[serde(rename = "type")]
1344            _tag: __Tag2,
1345            #[serde(rename = "cephAccessKey")]
1346            value: Strict<CephAccessKeyConfig>,
1347        }
1348        #[derive(Deserialize)]
1349        enum __Tag3 {
1350            #[serde(rename = "cephOidc")]
1351            Value,
1352        }
1353        #[derive(Deserialize)]
1354        #[serde(deny_unknown_fields)]
1355        struct __Arm3 {
1356            #[serde(rename = "type")]
1357            _tag: __Tag3,
1358            #[serde(rename = "cephOidc")]
1359            value: Strict<CephOidcConfig>,
1360        }
1361        #[derive(Deserialize)]
1362        enum __Tag4 {
1363            #[serde(rename = "gcsOidc")]
1364            Value,
1365        }
1366        #[derive(Deserialize)]
1367        #[serde(deny_unknown_fields)]
1368        struct __Arm4 {
1369            #[serde(rename = "type")]
1370            _tag: __Tag4,
1371            #[serde(rename = "gcsOidc")]
1372            value: Strict<GcsOidcConfig>,
1373        }
1374        #[derive(Deserialize)]
1375        enum __Tag5 {
1376            #[serde(rename = "gcsServiceAccountKey")]
1377            Value,
1378        }
1379        #[derive(Deserialize)]
1380        #[serde(deny_unknown_fields)]
1381        struct __Arm5 {
1382            #[serde(rename = "type")]
1383            _tag: __Tag5,
1384            #[serde(rename = "gcsServiceAccountKey")]
1385            value: Strict<GcsServiceAccountKeyConfig>,
1386        }
1387        #[derive(Deserialize)]
1388        enum __Tag6 {
1389            #[serde(rename = "huggingFaceToken")]
1390            Value,
1391        }
1392        #[derive(Deserialize)]
1393        #[serde(deny_unknown_fields)]
1394        struct __Arm6 {
1395            #[serde(rename = "type")]
1396            _tag: __Tag6,
1397            #[serde(rename = "huggingFaceToken")]
1398            value: Strict<HuggingFaceCredentialConfig>,
1399        }
1400        #[derive(Deserialize)]
1401        enum __Tag7 {
1402            #[serde(rename = "minioAccessKey")]
1403            Value,
1404        }
1405        #[derive(Deserialize)]
1406        #[serde(deny_unknown_fields)]
1407        struct __Arm7 {
1408            #[serde(rename = "type")]
1409            _tag: __Tag7,
1410            #[serde(rename = "minioAccessKey")]
1411            value: Strict<S3AccessKeyConfig>,
1412        }
1413        #[derive(Deserialize)]
1414        enum __Tag8 {
1415            #[serde(rename = "r2AccessKey")]
1416            Value,
1417        }
1418        #[derive(Deserialize)]
1419        #[serde(deny_unknown_fields)]
1420        struct __Arm8 {
1421            #[serde(rename = "type")]
1422            _tag: __Tag8,
1423            #[serde(rename = "r2AccessKey")]
1424            value: Strict<R2AccessKeyConfig>,
1425        }
1426        #[derive(Deserialize)]
1427        enum __Tag9 {
1428            #[serde(rename = "rustfsAccessKey")]
1429            Value,
1430        }
1431        #[derive(Deserialize)]
1432        #[serde(deny_unknown_fields)]
1433        struct __Arm9 {
1434            #[serde(rename = "type")]
1435            _tag: __Tag9,
1436            #[serde(rename = "rustfsAccessKey")]
1437            value: Strict<S3AccessKeyConfig>,
1438        }
1439        #[derive(Deserialize)]
1440        enum __Tag10 {
1441            #[serde(rename = "s3LikeAccessKey")]
1442            Value,
1443        }
1444        #[derive(Deserialize)]
1445        #[serde(deny_unknown_fields)]
1446        struct __Arm10 {
1447            #[serde(rename = "type")]
1448            _tag: __Tag10,
1449            #[serde(rename = "s3LikeAccessKey")]
1450            value: Strict<S3AccessKeyConfig>,
1451        }
1452        #[derive(Deserialize)]
1453        #[serde(untagged)]
1454        enum __Known {
1455            AwsAccessKey(Box<__Arm0>),
1456            AwsOidc(Box<__Arm1>),
1457            CephAccessKey(Box<__Arm2>),
1458            CephOidc(Box<__Arm3>),
1459            GcsOidc(Box<__Arm4>),
1460            GcsServiceAccountKey(Box<__Arm5>),
1461            HuggingFaceToken(Box<__Arm6>),
1462            MinioAccessKey(Box<__Arm7>),
1463            R2AccessKey(Box<__Arm8>),
1464            RustfsAccessKey(Box<__Arm9>),
1465            S3LikeAccessKey(Box<__Arm10>),
1466        }
1467        Ok(match __Known::deserialize(deserializer)? {
1468            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
1469            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
1470            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
1471            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
1472            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
1473            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
1474            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
1475            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
1476            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
1477            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
1478            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
1479        })
1480    }
1481}
1482
1483/// DropRecord contract value.
1484#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1485pub struct DropRecord {
1486    /// Contract field droppedAtMicros.
1487    #[serde(rename = "droppedAtMicros")]
1488    pub dropped_at_micros: SafeLong,
1489    /// Contract field droppedBy.
1490    #[serde(rename = "droppedBy")]
1491    pub dropped_by: String,
1492}
1493impl<'de> DeserializeStrict<'de> for DropRecord {
1494    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1495        #[derive(Deserialize)]
1496        #[serde(deny_unknown_fields)]
1497        struct __Wire {
1498            #[serde(rename = "droppedAtMicros")]
1499            dropped_at_micros: Strict<SafeLong>,
1500            #[serde(rename = "droppedBy")]
1501            dropped_by: Strict<String>,
1502        }
1503        let wire = __Wire::deserialize(deserializer)?;
1504        Ok(Self {
1505            dropped_at_micros: wire.dropped_at_micros.0,
1506            dropped_by: wire.dropped_by.0,
1507        })
1508    }
1509}
1510
1511/// DropResponse contract value.
1512#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1513pub struct DropResponse {
1514    /// Contract field dropped.
1515    #[serde(rename = "dropped")]
1516    pub dropped: DropRecord,
1517}
1518impl<'de> DeserializeStrict<'de> for DropResponse {
1519    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1520        #[derive(Deserialize)]
1521        #[serde(deny_unknown_fields)]
1522        struct __Wire {
1523            #[serde(rename = "dropped")]
1524            dropped: Strict<DropRecord>,
1525        }
1526        let wire = __Wire::deserialize(deserializer)?;
1527        Ok(Self {
1528            dropped: wire.dropped.0,
1529        })
1530    }
1531}
1532
1533/// GcsAccessToken contract value.
1534#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1535pub struct GcsAccessToken {
1536    /// Contract field accessToken.
1537    #[serde(rename = "accessToken")]
1538    pub access_token: SecretToken,
1539    /// Contract field expiresAtMicros.
1540    #[serde(rename = "expiresAtMicros")]
1541    pub expires_at_micros: SafeLong,
1542}
1543impl<'de> DeserializeStrict<'de> for GcsAccessToken {
1544    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1545        #[derive(Deserialize)]
1546        #[serde(deny_unknown_fields)]
1547        struct __Wire {
1548            #[serde(rename = "accessToken")]
1549            access_token: Strict<SecretToken>,
1550            #[serde(rename = "expiresAtMicros")]
1551            expires_at_micros: Strict<SafeLong>,
1552        }
1553        let wire = __Wire::deserialize(deserializer)?;
1554        Ok(Self {
1555            access_token: wire.access_token.0,
1556            expires_at_micros: wire.expires_at_micros.0,
1557        })
1558    }
1559}
1560
1561/// GcsOidc contract value.
1562#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1563pub struct GcsOidc {
1564    /// Contract field serviceAccount.
1565    #[serde(rename = "serviceAccount")]
1566    pub service_account: String,
1567    /// Contract field workloadIdentityProvider.
1568    #[serde(rename = "workloadIdentityProvider")]
1569    pub workload_identity_provider: String,
1570}
1571impl<'de> DeserializeStrict<'de> for GcsOidc {
1572    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1573        #[derive(Deserialize)]
1574        #[serde(deny_unknown_fields)]
1575        struct __Wire {
1576            #[serde(rename = "serviceAccount")]
1577            service_account: Strict<String>,
1578            #[serde(rename = "workloadIdentityProvider")]
1579            workload_identity_provider: Strict<String>,
1580        }
1581        let wire = __Wire::deserialize(deserializer)?;
1582        Ok(Self {
1583            service_account: wire.service_account.0,
1584            workload_identity_provider: wire.workload_identity_provider.0,
1585        })
1586    }
1587}
1588
1589/// GcsOidcConfig contract value.
1590#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1591pub struct GcsOidcConfig {
1592    /// Contract field serviceAccount.
1593    #[serde(rename = "serviceAccount")]
1594    pub service_account: String,
1595    /// Contract field workloadIdentityProvider.
1596    #[serde(rename = "workloadIdentityProvider")]
1597    pub workload_identity_provider: String,
1598}
1599impl<'de> DeserializeStrict<'de> for GcsOidcConfig {
1600    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1601        #[derive(Deserialize)]
1602        #[serde(deny_unknown_fields)]
1603        struct __Wire {
1604            #[serde(rename = "serviceAccount")]
1605            service_account: Strict<String>,
1606            #[serde(rename = "workloadIdentityProvider")]
1607            workload_identity_provider: Strict<String>,
1608        }
1609        let wire = __Wire::deserialize(deserializer)?;
1610        Ok(Self {
1611            service_account: wire.service_account.0,
1612            workload_identity_provider: wire.workload_identity_provider.0,
1613        })
1614    }
1615}
1616
1617/// GcsServiceAccountKey contract value.
1618#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1619pub struct GcsServiceAccountKey {
1620    /// Contract field keyJson.
1621    #[serde(rename = "keyJson")]
1622    pub key_json: SecretToken,
1623}
1624impl<'de> DeserializeStrict<'de> for GcsServiceAccountKey {
1625    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1626        #[derive(Deserialize)]
1627        #[serde(deny_unknown_fields)]
1628        struct __Wire {
1629            #[serde(rename = "keyJson")]
1630            key_json: Strict<SecretToken>,
1631        }
1632        let wire = __Wire::deserialize(deserializer)?;
1633        Ok(Self {
1634            key_json: wire.key_json.0,
1635        })
1636    }
1637}
1638
1639/// GcsServiceAccountKeyConfig contract value.
1640#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1641pub struct GcsServiceAccountKeyConfig {
1642    /// Contract field privateKeyId.
1643    #[serde(rename = "privateKeyId")]
1644    pub private_key_id: String,
1645    /// Contract field serviceAccount.
1646    #[serde(rename = "serviceAccount")]
1647    pub service_account: String,
1648}
1649impl<'de> DeserializeStrict<'de> for GcsServiceAccountKeyConfig {
1650    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1651        #[derive(Deserialize)]
1652        #[serde(deny_unknown_fields)]
1653        struct __Wire {
1654            #[serde(rename = "privateKeyId")]
1655            private_key_id: Strict<String>,
1656            #[serde(rename = "serviceAccount")]
1657            service_account: Strict<String>,
1658        }
1659        let wire = __Wire::deserialize(deserializer)?;
1660        Ok(Self {
1661            private_key_id: wire.private_key_id.0,
1662            service_account: wire.service_account.0,
1663        })
1664    }
1665}
1666
1667/// HuggingFaceCredential contract value.
1668#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1669pub struct HuggingFaceCredential {
1670    /// Contract field endpoint.
1671    #[serde(rename = "endpoint")]
1672    #[serde(default, skip_serializing_if = "Option::is_none")]
1673    pub endpoint: Option<String>,
1674    /// Contract field token.
1675    #[serde(rename = "token")]
1676    pub token: SecretToken,
1677}
1678impl<'de> DeserializeStrict<'de> for HuggingFaceCredential {
1679    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1680        #[derive(Deserialize)]
1681        #[serde(deny_unknown_fields)]
1682        struct __Wire {
1683            #[serde(rename = "endpoint")]
1684            #[serde(default)]
1685            endpoint: Strict<Option<String>>,
1686            #[serde(rename = "token")]
1687            token: Strict<SecretToken>,
1688        }
1689        let wire = __Wire::deserialize(deserializer)?;
1690        Ok(Self {
1691            endpoint: wire.endpoint.0,
1692            token: wire.token.0,
1693        })
1694    }
1695}
1696
1697/// HuggingFaceCredentialConfig contract value.
1698#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1699pub struct HuggingFaceCredentialConfig {
1700    /// Contract field endpoint.
1701    #[serde(rename = "endpoint")]
1702    #[serde(default, skip_serializing_if = "Option::is_none")]
1703    pub endpoint: Option<String>,
1704}
1705impl<'de> DeserializeStrict<'de> for HuggingFaceCredentialConfig {
1706    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1707        #[derive(Deserialize)]
1708        #[serde(deny_unknown_fields)]
1709        struct __Wire {
1710            #[serde(rename = "endpoint")]
1711            #[serde(default)]
1712            endpoint: Strict<Option<String>>,
1713        }
1714        let wire = __Wire::deserialize(deserializer)?;
1715        Ok(Self {
1716            endpoint: wire.endpoint.0,
1717        })
1718    }
1719}
1720
1721/// HuggingFaceToken contract value.
1722#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1723pub struct HuggingFaceToken {
1724    /// Contract field endpoint.
1725    #[serde(rename = "endpoint")]
1726    pub endpoint: String,
1727    /// Contract field expiresAtMicros.
1728    #[serde(rename = "expiresAtMicros")]
1729    pub expires_at_micros: SafeLong,
1730    /// Contract field token.
1731    #[serde(rename = "token")]
1732    pub token: SecretToken,
1733}
1734impl<'de> DeserializeStrict<'de> for HuggingFaceToken {
1735    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1736        #[derive(Deserialize)]
1737        #[serde(deny_unknown_fields)]
1738        struct __Wire {
1739            #[serde(rename = "endpoint")]
1740            endpoint: Strict<String>,
1741            #[serde(rename = "expiresAtMicros")]
1742            expires_at_micros: Strict<SafeLong>,
1743            #[serde(rename = "token")]
1744            token: Strict<SecretToken>,
1745        }
1746        let wire = __Wire::deserialize(deserializer)?;
1747        Ok(Self {
1748            endpoint: wire.endpoint.0,
1749            expires_at_micros: wire.expires_at_micros.0,
1750            token: wire.token.0,
1751        })
1752    }
1753}
1754
1755/// R2AccessKey contract value.
1756#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1757pub struct R2AccessKey {
1758    /// Contract field accessKeyId.
1759    #[serde(rename = "accessKeyId")]
1760    pub access_key_id: String,
1761    /// Contract field accountId.
1762    #[serde(rename = "accountId")]
1763    pub account_id: String,
1764    /// Contract field jurisdiction.
1765    #[serde(rename = "jurisdiction")]
1766    #[serde(default, skip_serializing_if = "Option::is_none")]
1767    pub jurisdiction: Option<R2Jurisdiction>,
1768    /// Contract field secretAccessKey.
1769    #[serde(rename = "secretAccessKey")]
1770    pub secret_access_key: SecretToken,
1771}
1772impl<'de> DeserializeStrict<'de> for R2AccessKey {
1773    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1774        #[derive(Deserialize)]
1775        #[serde(deny_unknown_fields)]
1776        struct __Wire {
1777            #[serde(rename = "accessKeyId")]
1778            access_key_id: Strict<String>,
1779            #[serde(rename = "accountId")]
1780            account_id: Strict<String>,
1781            #[serde(rename = "jurisdiction")]
1782            #[serde(default)]
1783            jurisdiction: Strict<Option<R2Jurisdiction>>,
1784            #[serde(rename = "secretAccessKey")]
1785            secret_access_key: Strict<SecretToken>,
1786        }
1787        let wire = __Wire::deserialize(deserializer)?;
1788        Ok(Self {
1789            access_key_id: wire.access_key_id.0,
1790            account_id: wire.account_id.0,
1791            jurisdiction: wire.jurisdiction.0,
1792            secret_access_key: wire.secret_access_key.0,
1793        })
1794    }
1795}
1796
1797/// R2AccessKeyConfig contract value.
1798#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1799pub struct R2AccessKeyConfig {
1800    /// Contract field accessKeyId.
1801    #[serde(rename = "accessKeyId")]
1802    pub access_key_id: String,
1803    /// Contract field accountId.
1804    #[serde(rename = "accountId")]
1805    pub account_id: String,
1806    /// Contract field jurisdiction.
1807    #[serde(rename = "jurisdiction")]
1808    #[serde(default, skip_serializing_if = "Option::is_none")]
1809    pub jurisdiction: Option<R2Jurisdiction>,
1810}
1811impl<'de> DeserializeStrict<'de> for R2AccessKeyConfig {
1812    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1813        #[derive(Deserialize)]
1814        #[serde(deny_unknown_fields)]
1815        struct __Wire {
1816            #[serde(rename = "accessKeyId")]
1817            access_key_id: Strict<String>,
1818            #[serde(rename = "accountId")]
1819            account_id: Strict<String>,
1820            #[serde(rename = "jurisdiction")]
1821            #[serde(default)]
1822            jurisdiction: Strict<Option<R2Jurisdiction>>,
1823        }
1824        let wire = __Wire::deserialize(deserializer)?;
1825        Ok(Self {
1826            access_key_id: wire.access_key_id.0,
1827            account_id: wire.account_id.0,
1828            jurisdiction: wire.jurisdiction.0,
1829        })
1830    }
1831}
1832
1833/// R2Jurisdiction contract value.
1834#[derive(Clone, Debug, PartialEq, Eq)]
1835pub enum R2Jurisdiction {
1836    /// A known contract value.
1837    Eu,
1838    /// A known contract value.
1839    Fedramp,
1840    /// A known contract value.
1841    Us,
1842    /// A value introduced by a newer server.
1843    Unknown(String),
1844}
1845impl Serialize for R2Jurisdiction {
1846    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1847        serializer.serialize_str(match self {
1848            Self::Eu => "eu",
1849            Self::Fedramp => "fedramp",
1850            Self::Us => "us",
1851            Self::Unknown(value) => value,
1852        })
1853    }
1854}
1855impl<'de> Deserialize<'de> for R2Jurisdiction {
1856    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1857        Ok(match String::deserialize(deserializer)?.as_str() {
1858            "eu" => Self::Eu,
1859            "fedramp" => Self::Fedramp,
1860            "us" => Self::Us,
1861            value => Self::Unknown(value.to_owned()),
1862        })
1863    }
1864}
1865impl<'de> DeserializeStrict<'de> for R2Jurisdiction {
1866    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1867        #[derive(Deserialize)]
1868        enum __Known {
1869            #[serde(rename = "eu")]
1870            Eu,
1871            #[serde(rename = "fedramp")]
1872            Fedramp,
1873            #[serde(rename = "us")]
1874            Us,
1875        }
1876        Ok(match __Known::deserialize(deserializer)? {
1877            __Known::Eu => Self::Eu,
1878            __Known::Fedramp => Self::Fedramp,
1879            __Known::Us => Self::Us,
1880        })
1881    }
1882}
1883
1884/// S3AccessKey contract value.
1885#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1886pub struct S3AccessKey {
1887    /// Contract field accessKeyId.
1888    #[serde(rename = "accessKeyId")]
1889    pub access_key_id: String,
1890    /// Contract field endpoint.
1891    #[serde(rename = "endpoint")]
1892    pub endpoint: String,
1893    /// Contract field region.
1894    #[serde(rename = "region")]
1895    #[serde(default, skip_serializing_if = "Option::is_none")]
1896    pub region: Option<String>,
1897    /// Contract field secretAccessKey.
1898    #[serde(rename = "secretAccessKey")]
1899    pub secret_access_key: SecretToken,
1900}
1901impl<'de> DeserializeStrict<'de> for S3AccessKey {
1902    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1903        #[derive(Deserialize)]
1904        #[serde(deny_unknown_fields)]
1905        struct __Wire {
1906            #[serde(rename = "accessKeyId")]
1907            access_key_id: Strict<String>,
1908            #[serde(rename = "endpoint")]
1909            endpoint: Strict<String>,
1910            #[serde(rename = "region")]
1911            #[serde(default)]
1912            region: Strict<Option<String>>,
1913            #[serde(rename = "secretAccessKey")]
1914            secret_access_key: Strict<SecretToken>,
1915        }
1916        let wire = __Wire::deserialize(deserializer)?;
1917        Ok(Self {
1918            access_key_id: wire.access_key_id.0,
1919            endpoint: wire.endpoint.0,
1920            region: wire.region.0,
1921            secret_access_key: wire.secret_access_key.0,
1922        })
1923    }
1924}
1925
1926/// S3AccessKeyConfig contract value.
1927#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1928pub struct S3AccessKeyConfig {
1929    /// Contract field accessKeyId.
1930    #[serde(rename = "accessKeyId")]
1931    pub access_key_id: String,
1932    /// Contract field endpoint.
1933    #[serde(rename = "endpoint")]
1934    pub endpoint: String,
1935    /// Contract field region.
1936    #[serde(rename = "region")]
1937    #[serde(default, skip_serializing_if = "Option::is_none")]
1938    pub region: Option<String>,
1939}
1940impl<'de> DeserializeStrict<'de> for S3AccessKeyConfig {
1941    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1942        #[derive(Deserialize)]
1943        #[serde(deny_unknown_fields)]
1944        struct __Wire {
1945            #[serde(rename = "accessKeyId")]
1946            access_key_id: Strict<String>,
1947            #[serde(rename = "endpoint")]
1948            endpoint: Strict<String>,
1949            #[serde(rename = "region")]
1950            #[serde(default)]
1951            region: Strict<Option<String>>,
1952        }
1953        let wire = __Wire::deserialize(deserializer)?;
1954        Ok(Self {
1955            access_key_id: wire.access_key_id.0,
1956            endpoint: wire.endpoint.0,
1957            region: wire.region.0,
1958        })
1959    }
1960}
1961
1962/// A secret credential value.
1963#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
1964#[serde(transparent)]
1965pub struct SecretToken(pub String);
1966impl std::fmt::Debug for SecretToken {
1967    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1968        formatter.write_str("SecretToken(<redacted>)")
1969    }
1970}
1971impl<'de> DeserializeStrict<'de> for SecretToken {
1972    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1973        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
1974    }
1975}
1976
1977/// TestResponse contract value.
1978#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1979pub struct TestResponse {
1980    /// Contract field access.
1981    #[serde(rename = "access")]
1982    #[serde(default, skip_serializing_if = "Option::is_none")]
1983    pub access: Option<TestStep>,
1984    /// Contract field vend.
1985    #[serde(rename = "vend")]
1986    pub vend: TestStep,
1987    /// Contract field write.
1988    #[serde(rename = "write")]
1989    #[serde(default, skip_serializing_if = "Option::is_none")]
1990    pub write: Option<TestStep>,
1991}
1992impl<'de> DeserializeStrict<'de> for TestResponse {
1993    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1994        #[derive(Deserialize)]
1995        #[serde(deny_unknown_fields)]
1996        struct __Wire {
1997            #[serde(rename = "access")]
1998            #[serde(default)]
1999            access: Strict<Option<TestStep>>,
2000            #[serde(rename = "vend")]
2001            vend: Strict<TestStep>,
2002            #[serde(rename = "write")]
2003            #[serde(default)]
2004            write: Strict<Option<TestStep>>,
2005        }
2006        let wire = __Wire::deserialize(deserializer)?;
2007        Ok(Self {
2008            access: wire.access.0,
2009            vend: wire.vend.0,
2010            write: wire.write.0,
2011        })
2012    }
2013}
2014
2015/// TestStep contract value.
2016#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2017pub struct TestStep {
2018    /// Contract field detail.
2019    #[serde(rename = "detail")]
2020    pub detail: String,
2021    /// Contract field succeeded.
2022    #[serde(rename = "succeeded")]
2023    pub succeeded: bool,
2024}
2025impl<'de> DeserializeStrict<'de> for TestStep {
2026    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2027        #[derive(Deserialize)]
2028        #[serde(deny_unknown_fields)]
2029        struct __Wire {
2030            #[serde(rename = "detail")]
2031            detail: Strict<String>,
2032            #[serde(rename = "succeeded")]
2033            succeeded: Strict<bool>,
2034        }
2035        let wire = __Wire::deserialize(deserializer)?;
2036        Ok(Self {
2037            detail: wire.detail.0,
2038            succeeded: wire.succeeded.0,
2039        })
2040    }
2041}
2042
2043/// UpdateAllowedAccessRequest contract value.
2044#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2045pub struct UpdateAllowedAccessRequest {
2046    /// Contract field allowedAccess.
2047    #[serde(rename = "allowedAccess")]
2048    pub allowed_access: ConnectionAccess,
2049}
2050impl<'de> DeserializeStrict<'de> for UpdateAllowedAccessRequest {
2051    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2052        #[derive(Deserialize)]
2053        #[serde(deny_unknown_fields)]
2054        struct __Wire {
2055            #[serde(rename = "allowedAccess")]
2056            allowed_access: Strict<ConnectionAccess>,
2057        }
2058        let wire = __Wire::deserialize(deserializer)?;
2059        Ok(Self {
2060            allowed_access: wire.allowed_access.0,
2061        })
2062    }
2063}
2064
2065/// UpdateCredentialRequest contract value.
2066#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2067pub struct UpdateCredentialRequest {
2068    /// Contract field credential.
2069    #[serde(rename = "credential")]
2070    pub credential: Credential,
2071}
2072impl<'de> DeserializeStrict<'de> for UpdateCredentialRequest {
2073    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2074        #[derive(Deserialize)]
2075        #[serde(deny_unknown_fields)]
2076        struct __Wire {
2077            #[serde(rename = "credential")]
2078            credential: Strict<Credential>,
2079        }
2080        let wire = __Wire::deserialize(deserializer)?;
2081        Ok(Self {
2082            credential: wire.credential.0,
2083        })
2084    }
2085}
2086
2087/// UpdateDescriptionRequest contract value.
2088#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2089pub struct UpdateDescriptionRequest {
2090    /// Contract field description.
2091    #[serde(rename = "description")]
2092    #[serde(default, skip_serializing_if = "Option::is_none")]
2093    pub description: Option<String>,
2094}
2095impl<'de> DeserializeStrict<'de> for UpdateDescriptionRequest {
2096    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2097        #[derive(Deserialize)]
2098        #[serde(deny_unknown_fields)]
2099        struct __Wire {
2100            #[serde(rename = "description")]
2101            #[serde(default)]
2102            description: Strict<Option<String>>,
2103        }
2104        let wire = __Wire::deserialize(deserializer)?;
2105        Ok(Self {
2106            description: wire.description.0,
2107        })
2108    }
2109}
2110
2111/// VendRequest contract value.
2112#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2113pub struct VendRequest {
2114    /// Contract field uri.
2115    #[serde(rename = "uri")]
2116    pub uri: String,
2117}
2118impl<'de> DeserializeStrict<'de> for VendRequest {
2119    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2120        #[derive(Deserialize)]
2121        #[serde(deny_unknown_fields)]
2122        struct __Wire {
2123            #[serde(rename = "uri")]
2124            uri: Strict<String>,
2125        }
2126        let wire = __Wire::deserialize(deserializer)?;
2127        Ok(Self { uri: wire.uri.0 })
2128    }
2129}
2130
2131/// VendResponse contract value.
2132#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
2133pub struct VendResponse {
2134    /// Contract field credential.
2135    #[serde(rename = "credential")]
2136    pub credential: VendedCredential,
2137}
2138impl<'de> DeserializeStrict<'de> for VendResponse {
2139    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2140        #[derive(Deserialize)]
2141        #[serde(deny_unknown_fields)]
2142        struct __Wire {
2143            #[serde(rename = "credential")]
2144            credential: Strict<VendedCredential>,
2145        }
2146        let wire = __Wire::deserialize(deserializer)?;
2147        Ok(Self {
2148            credential: wire.credential.0,
2149        })
2150    }
2151}
2152
2153/// A short-lived provider credential. Renew it before it expires.
2154#[derive(Clone, Debug, PartialEq, Eq)]
2155pub enum VendedCredential {
2156    /// A known union arm.
2157    AwsSession(AwsSession),
2158    /// A known union arm.
2159    GcsAccessToken(GcsAccessToken),
2160    /// A known union arm.
2161    HuggingFaceToken(HuggingFaceToken),
2162    /// An unknown discriminator and its complete wire object.
2163    Unknown { tag: String, value: Value },
2164}
2165impl Serialize for VendedCredential {
2166    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2167        match self {
2168            Self::AwsSession(value) => {
2169                let mut object = serde_json::Map::new();
2170                object.insert("type".into(), Value::String("awsSession".into()));
2171                object.insert(
2172                    "awsSession".into(),
2173                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2174                );
2175                Value::Object(object).serialize(serializer)
2176            }
2177            Self::GcsAccessToken(value) => {
2178                let mut object = serde_json::Map::new();
2179                object.insert("type".into(), Value::String("gcsAccessToken".into()));
2180                object.insert(
2181                    "gcsAccessToken".into(),
2182                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2183                );
2184                Value::Object(object).serialize(serializer)
2185            }
2186            Self::HuggingFaceToken(value) => {
2187                let mut object = serde_json::Map::new();
2188                object.insert("type".into(), Value::String("huggingFaceToken".into()));
2189                object.insert(
2190                    "huggingFaceToken".into(),
2191                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
2192                );
2193                Value::Object(object).serialize(serializer)
2194            }
2195            Self::Unknown { tag, value } => {
2196                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
2197                    return Err(serde::ser::Error::custom(
2198                        "unknown union discriminator mismatch",
2199                    ));
2200                }
2201                value.serialize(serializer)
2202            }
2203        }
2204    }
2205}
2206impl<'de> Deserialize<'de> for VendedCredential {
2207    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2208        let value = Value::deserialize(deserializer)?;
2209        let tag = value
2210            .get("type")
2211            .and_then(Value::as_str)
2212            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
2213        match tag {
2214            "awsSession" => Ok(Self::AwsSession(
2215                serde_json::from_value(
2216                    value
2217                        .get("awsSession")
2218                        .cloned()
2219                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2220                )
2221                .map_err(serde::de::Error::custom)?,
2222            )),
2223            "gcsAccessToken" => Ok(Self::GcsAccessToken(
2224                serde_json::from_value(
2225                    value
2226                        .get("gcsAccessToken")
2227                        .cloned()
2228                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
2229                )
2230                .map_err(serde::de::Error::custom)?,
2231            )),
2232            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
2233                serde_json::from_value(
2234                    value
2235                        .get("huggingFaceToken")
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 VendedCredential {
2249    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2250        #[derive(Deserialize)]
2251        enum __Tag0 {
2252            #[serde(rename = "awsSession")]
2253            Value,
2254        }
2255        #[derive(Deserialize)]
2256        #[serde(deny_unknown_fields)]
2257        struct __Arm0 {
2258            #[serde(rename = "type")]
2259            _tag: __Tag0,
2260            #[serde(rename = "awsSession")]
2261            value: Strict<AwsSession>,
2262        }
2263        #[derive(Deserialize)]
2264        enum __Tag1 {
2265            #[serde(rename = "gcsAccessToken")]
2266            Value,
2267        }
2268        #[derive(Deserialize)]
2269        #[serde(deny_unknown_fields)]
2270        struct __Arm1 {
2271            #[serde(rename = "type")]
2272            _tag: __Tag1,
2273            #[serde(rename = "gcsAccessToken")]
2274            value: Strict<GcsAccessToken>,
2275        }
2276        #[derive(Deserialize)]
2277        enum __Tag2 {
2278            #[serde(rename = "huggingFaceToken")]
2279            Value,
2280        }
2281        #[derive(Deserialize)]
2282        #[serde(deny_unknown_fields)]
2283        struct __Arm2 {
2284            #[serde(rename = "type")]
2285            _tag: __Tag2,
2286            #[serde(rename = "huggingFaceToken")]
2287            value: Strict<HuggingFaceToken>,
2288        }
2289        #[derive(Deserialize)]
2290        #[serde(untagged)]
2291        enum __Known {
2292            AwsSession(Box<__Arm0>),
2293            GcsAccessToken(Box<__Arm1>),
2294            HuggingFaceToken(Box<__Arm2>),
2295        }
2296        Ok(match __Known::deserialize(deserializer)? {
2297            __Known::AwsSession(arm) => Self::AwsSession(arm.value.0),
2298            __Known::GcsAccessToken(arm) => Self::GcsAccessToken(arm.value.0),
2299            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
2300        })
2301    }
2302}
2303
2304/// Typed errors declared by this service contract.
2305#[derive(Clone, Debug, PartialEq, Eq)]
2306pub enum ConnectionsError {
2307    /// Connections:Conflict.
2308    Conflict { reason: String },
2309    /// Connections:InvalidArgument.
2310    InvalidArgument { reason: String },
2311    /// Connections:NotFound.
2312    NotFound { resource: String },
2313}
2314impl ConnectionsError {
2315    /// HTTP status for this declared error.
2316    pub fn status(&self) -> u16 {
2317        match self {
2318            Self::Conflict { .. } => 409,
2319            Self::InvalidArgument { .. } => 400,
2320            Self::NotFound { .. } => 404,
2321        }
2322    }
2323    /// Serialize only contract-declared error parameters.
2324    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
2325        match self {
2326            Self::Conflict { reason } => {
2327                let mut envelope = ErrorEnvelope::new("CONFLICT", "Connections:Conflict", instance);
2328                envelope
2329                    .parameters
2330                    .insert("reason".into(), reason.to_string());
2331                envelope
2332            }
2333            Self::InvalidArgument { reason } => {
2334                let mut envelope =
2335                    ErrorEnvelope::new("INVALID_ARGUMENT", "Connections:InvalidArgument", instance);
2336                envelope
2337                    .parameters
2338                    .insert("reason".into(), reason.to_string());
2339                envelope
2340            }
2341            Self::NotFound { resource } => {
2342                let mut envelope =
2343                    ErrorEnvelope::new("NOT_FOUND", "Connections:NotFound", instance);
2344                envelope
2345                    .parameters
2346                    .insert("resource".into(), resource.to_string());
2347                envelope
2348            }
2349        }
2350    }
2351    /// Decode a declared error and its typed error parameters.
2352    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
2353        if envelope.error_instance_id.len() != 36
2354            || Uuid::parse_str(&envelope.error_instance_id).is_err()
2355        {
2356            return None;
2357        }
2358        match envelope.error_name.as_str() {
2359            "Connections:Conflict" => {
2360                if envelope.error_code != "CONFLICT" {
2361                    return None;
2362                }
2363                let reason = envelope.parameters.get("reason")?.clone();
2364                Some(Self::Conflict { reason })
2365            }
2366            "Connections:InvalidArgument" => {
2367                if envelope.error_code != "INVALID_ARGUMENT" {
2368                    return None;
2369                }
2370                let reason = envelope.parameters.get("reason")?.clone();
2371                Some(Self::InvalidArgument { reason })
2372            }
2373            "Connections:NotFound" => {
2374                if envelope.error_code != "NOT_FOUND" {
2375                    return None;
2376                }
2377                let resource = envelope.parameters.get("resource")?.clone();
2378                Some(Self::NotFound { resource })
2379            }
2380            _ => None,
2381        }
2382    }
2383}
2384impl Display for ConnectionsError {
2385    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
2386        match self {
2387            Self::Conflict { reason } => {
2388                write!(formatter, "Connections:Conflict (reason: {})", reason)
2389            }
2390            Self::InvalidArgument { reason } => write!(
2391                formatter,
2392                "Connections:InvalidArgument (reason: {})",
2393                reason
2394            ),
2395            Self::NotFound { resource } => {
2396                write!(formatter, "Connections:NotFound (resource: {})", resource)
2397            }
2398        }
2399    }
2400}
2401impl StdError for ConnectionsError {}
2402impl ServiceError for ConnectionsError {
2403    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
2404        Self::envelope(self, instance)
2405    }
2406    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
2407        Self::decode_envelope(envelope)
2408    }
2409}
2410#[automatically_derived]
2411impl Default for UpdateDescriptionRequest {
2412    fn default() -> Self {
2413        Self { description: None }
2414    }
2415}