spiral/api/tables/
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, SafeUnsignedLong};
11use spiral_contract::strict::{DeserializeStrict, Strict};
12use uuid::Uuid;
13
14/// AwsSession contract value.
15#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
16pub struct AwsSession {
17    /// Contract field accessKeyId.
18    #[serde(rename = "accessKeyId")]
19    pub access_key_id: String,
20    /// Contract field endpoint.
21    #[serde(rename = "endpoint")]
22    #[serde(default, skip_serializing_if = "Option::is_none")]
23    pub endpoint: Option<String>,
24    /// Contract field expiresAtMicros.
25    #[serde(rename = "expiresAtMicros")]
26    pub expires_at_micros: SafeLong,
27    /// Contract field region.
28    #[serde(rename = "region")]
29    pub region: String,
30    /// Contract field secretAccessKey.
31    #[serde(rename = "secretAccessKey")]
32    pub secret_access_key: SecretToken,
33    /// Contract field sessionToken.
34    #[serde(rename = "sessionToken")]
35    pub session_token: SecretToken,
36}
37impl<'de> DeserializeStrict<'de> for AwsSession {
38    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
39        #[derive(Deserialize)]
40        #[serde(deny_unknown_fields)]
41        struct __Wire {
42            #[serde(rename = "accessKeyId")]
43            access_key_id: Strict<String>,
44            #[serde(rename = "endpoint")]
45            #[serde(default)]
46            endpoint: Strict<Option<String>>,
47            #[serde(rename = "expiresAtMicros")]
48            expires_at_micros: Strict<SafeLong>,
49            #[serde(rename = "region")]
50            region: Strict<String>,
51            #[serde(rename = "secretAccessKey")]
52            secret_access_key: Strict<SecretToken>,
53            #[serde(rename = "sessionToken")]
54            session_token: Strict<SecretToken>,
55        }
56        let wire = __Wire::deserialize(deserializer)?;
57        Ok(Self {
58            access_key_id: wire.access_key_id.0,
59            endpoint: wire.endpoint.0,
60            expires_at_micros: wire.expires_at_micros.0,
61            region: wire.region.0,
62            secret_access_key: wire.secret_access_key.0,
63            session_token: wire.session_token.0,
64        })
65    }
66}
67
68/// CreateTableRequest contract value.
69#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
70pub struct CreateTableRequest {
71    /// Contract field projectId.
72    #[serde(rename = "projectId")]
73    pub project_id: String,
74}
75impl<'de> DeserializeStrict<'de> for CreateTableRequest {
76    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
77        #[derive(Deserialize)]
78        #[serde(deny_unknown_fields)]
79        struct __Wire {
80            #[serde(rename = "projectId")]
81            project_id: Strict<String>,
82        }
83        let wire = __Wire::deserialize(deserializer)?;
84        Ok(Self {
85            project_id: wire.project_id.0,
86        })
87    }
88}
89
90/// CreateTableResponse contract value.
91#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
92pub struct CreateTableResponse {
93    /// Contract field rootUri.
94    #[serde(rename = "rootUri")]
95    pub root_uri: String,
96    /// Contract field tableId.
97    #[serde(rename = "tableId")]
98    pub table_id: TableId,
99}
100impl<'de> DeserializeStrict<'de> for CreateTableResponse {
101    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
102        #[derive(Deserialize)]
103        #[serde(deny_unknown_fields)]
104        struct __Wire {
105            #[serde(rename = "rootUri")]
106            root_uri: Strict<String>,
107            #[serde(rename = "tableId")]
108            table_id: Strict<TableId>,
109        }
110        let wire = __Wire::deserialize(deserializer)?;
111        Ok(Self {
112            root_uri: wire.root_uri.0,
113            table_id: wire.table_id.0,
114        })
115    }
116}
117
118/// CreateVersionRequest contract value.
119#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
120pub struct CreateVersionRequest {
121    /// Contract field baseVersionId.
122    #[serde(rename = "baseVersionId")]
123    #[serde(default, skip_serializing_if = "Option::is_none")]
124    pub base_version_id: Option<Uuid>,
125    /// Contract field versionId.
126    #[serde(rename = "versionId")]
127    pub version_id: Uuid,
128}
129impl<'de> DeserializeStrict<'de> for CreateVersionRequest {
130    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
131        #[derive(Deserialize)]
132        #[serde(deny_unknown_fields)]
133        struct __Wire {
134            #[serde(rename = "baseVersionId")]
135            #[serde(default)]
136            base_version_id: Strict<Option<Uuid>>,
137            #[serde(rename = "versionId")]
138            version_id: Strict<Uuid>,
139        }
140        let wire = __Wire::deserialize(deserializer)?;
141        Ok(Self {
142            base_version_id: wire.base_version_id.0,
143            version_id: wire.version_id.0,
144        })
145    }
146}
147
148/// CreateVersionResponse contract value.
149#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
150pub struct CreateVersionResponse {
151    /// Contract field parentVersionId.
152    #[serde(rename = "parentVersionId")]
153    #[serde(default, skip_serializing_if = "Option::is_none")]
154    pub parent_version_id: Option<Uuid>,
155    /// Contract field seqNo.
156    #[serde(rename = "seqNo")]
157    pub seq_no: SafeUnsignedLong,
158    /// Contract field versionId.
159    #[serde(rename = "versionId")]
160    pub version_id: Uuid,
161}
162impl<'de> DeserializeStrict<'de> for CreateVersionResponse {
163    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
164        #[derive(Deserialize)]
165        #[serde(deny_unknown_fields)]
166        struct __Wire {
167            #[serde(rename = "parentVersionId")]
168            #[serde(default)]
169            parent_version_id: Strict<Option<Uuid>>,
170            #[serde(rename = "seqNo")]
171            seq_no: Strict<SafeUnsignedLong>,
172            #[serde(rename = "versionId")]
173            version_id: Strict<Uuid>,
174        }
175        let wire = __Wire::deserialize(deserializer)?;
176        Ok(Self {
177            parent_version_id: wire.parent_version_id.0,
178            seq_no: wire.seq_no.0,
179            version_id: wire.version_id.0,
180        })
181    }
182}
183
184/// DirectRead contract value.
185#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
186pub struct DirectRead {
187    /// Contract field credential.
188    #[serde(rename = "credential")]
189    pub credential: VendedCredential,
190    /// Contract field uri.
191    #[serde(rename = "uri")]
192    pub uri: String,
193}
194impl<'de> DeserializeStrict<'de> for DirectRead {
195    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
196        #[derive(Deserialize)]
197        #[serde(deny_unknown_fields)]
198        struct __Wire {
199            #[serde(rename = "credential")]
200            credential: Strict<VendedCredential>,
201            #[serde(rename = "uri")]
202            uri: Strict<String>,
203        }
204        let wire = __Wire::deserialize(deserializer)?;
205        Ok(Self {
206            credential: wire.credential.0,
207            uri: wire.uri.0,
208        })
209    }
210}
211
212/// Empty contract value.
213#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
214pub struct Empty {}
215impl<'de> DeserializeStrict<'de> for Empty {
216    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
217        #[derive(Deserialize)]
218        #[serde(deny_unknown_fields)]
219        struct __Wire {}
220        __Wire::deserialize(deserializer)?;
221        Ok(Self {})
222    }
223}
224
225/// GcsAccessToken contract value.
226#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
227pub struct GcsAccessToken {
228    /// Contract field accessToken.
229    #[serde(rename = "accessToken")]
230    pub access_token: SecretToken,
231    /// Contract field expiresAtMicros.
232    #[serde(rename = "expiresAtMicros")]
233    pub expires_at_micros: SafeLong,
234}
235impl<'de> DeserializeStrict<'de> for GcsAccessToken {
236    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
237        #[derive(Deserialize)]
238        #[serde(deny_unknown_fields)]
239        struct __Wire {
240            #[serde(rename = "accessToken")]
241            access_token: Strict<SecretToken>,
242            #[serde(rename = "expiresAtMicros")]
243            expires_at_micros: Strict<SafeLong>,
244        }
245        let wire = __Wire::deserialize(deserializer)?;
246        Ok(Self {
247            access_token: wire.access_token.0,
248            expires_at_micros: wire.expires_at_micros.0,
249        })
250    }
251}
252
253/// HuggingFaceToken contract value.
254#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
255pub struct HuggingFaceToken {
256    /// Contract field endpoint.
257    #[serde(rename = "endpoint")]
258    pub endpoint: String,
259    /// Contract field expiresAtMicros.
260    #[serde(rename = "expiresAtMicros")]
261    pub expires_at_micros: SafeLong,
262    /// Contract field token.
263    #[serde(rename = "token")]
264    pub token: SecretToken,
265}
266impl<'de> DeserializeStrict<'de> for HuggingFaceToken {
267    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
268        #[derive(Deserialize)]
269        #[serde(deny_unknown_fields)]
270        struct __Wire {
271            #[serde(rename = "endpoint")]
272            endpoint: Strict<String>,
273            #[serde(rename = "expiresAtMicros")]
274            expires_at_micros: Strict<SafeLong>,
275            #[serde(rename = "token")]
276            token: Strict<SecretToken>,
277        }
278        let wire = __Wire::deserialize(deserializer)?;
279        Ok(Self {
280            endpoint: wire.endpoint.0,
281            expires_at_micros: wire.expires_at_micros.0,
282            token: wire.token.0,
283        })
284    }
285}
286
287/// ReadVersionResponse contract value.
288#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
289pub struct ReadVersionResponse {
290    /// Contract field parentVersionId.
291    #[serde(rename = "parentVersionId")]
292    #[serde(default, skip_serializing_if = "Option::is_none")]
293    pub parent_version_id: Option<Uuid>,
294    /// Contract field projectId.
295    #[serde(rename = "projectId")]
296    #[serde(default, skip_serializing_if = "Option::is_none")]
297    pub project_id: Option<String>,
298    /// Contract field rootUri.
299    #[serde(rename = "rootUri")]
300    pub root_uri: String,
301    /// Contract field seqNo.
302    #[serde(rename = "seqNo")]
303    pub seq_no: SafeUnsignedLong,
304}
305impl<'de> DeserializeStrict<'de> for ReadVersionResponse {
306    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
307        #[derive(Deserialize)]
308        #[serde(deny_unknown_fields)]
309        struct __Wire {
310            #[serde(rename = "parentVersionId")]
311            #[serde(default)]
312            parent_version_id: Strict<Option<Uuid>>,
313            #[serde(rename = "projectId")]
314            #[serde(default)]
315            project_id: Strict<Option<String>>,
316            #[serde(rename = "rootUri")]
317            root_uri: Strict<String>,
318            #[serde(rename = "seqNo")]
319            seq_no: Strict<SafeUnsignedLong>,
320        }
321        let wire = __Wire::deserialize(deserializer)?;
322        Ok(Self {
323            parent_version_id: wire.parent_version_id.0,
324            project_id: wire.project_id.0,
325            root_uri: wire.root_uri.0,
326            seq_no: wire.seq_no.0,
327        })
328    }
329}
330
331/// A secret credential value.
332#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
333#[serde(transparent)]
334pub struct SecretToken(pub String);
335impl std::fmt::Debug for SecretToken {
336    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
337        formatter.write_str("SecretToken(<redacted>)")
338    }
339}
340impl<'de> DeserializeStrict<'de> for SecretToken {
341    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
342        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
343    }
344}
345
346/// SignedAccess contract value.
347#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
348pub struct SignedAccess {
349    /// Contract field directRead.
350    #[serde(rename = "directRead")]
351    #[serde(default, skip_serializing_if = "Option::is_none")]
352    pub direct_read: Option<DirectRead>,
353    /// Contract field endpoint.
354    #[serde(rename = "endpoint")]
355    pub endpoint: String,
356    /// Contract field token.
357    #[serde(rename = "token")]
358    pub token: SecretToken,
359}
360impl<'de> DeserializeStrict<'de> for SignedAccess {
361    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
362        #[derive(Deserialize)]
363        #[serde(deny_unknown_fields)]
364        struct __Wire {
365            #[serde(rename = "directRead")]
366            #[serde(default)]
367            direct_read: Strict<Option<DirectRead>>,
368            #[serde(rename = "endpoint")]
369            endpoint: Strict<String>,
370            #[serde(rename = "token")]
371            token: Strict<SecretToken>,
372        }
373        let wire = __Wire::deserialize(deserializer)?;
374        Ok(Self {
375            direct_read: wire.direct_read.0,
376            endpoint: wire.endpoint.0,
377            token: wire.token.0,
378        })
379    }
380}
381
382/// StorageAccess contract value.
383#[derive(Clone, Debug, PartialEq, Eq)]
384pub enum StorageAccess {
385    /// A known union arm.
386    Signed(SignedAccess),
387    /// A known union arm.
388    Vended(VendedAccess),
389    /// An unknown discriminator and its complete wire object.
390    Unknown { tag: String, value: Value },
391}
392impl Serialize for StorageAccess {
393    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
394        match self {
395            Self::Signed(value) => {
396                let mut object = serde_json::Map::new();
397                object.insert("type".into(), Value::String("signed".into()));
398                object.insert(
399                    "signed".into(),
400                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
401                );
402                Value::Object(object).serialize(serializer)
403            }
404            Self::Vended(value) => {
405                let mut object = serde_json::Map::new();
406                object.insert("type".into(), Value::String("vended".into()));
407                object.insert(
408                    "vended".into(),
409                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
410                );
411                Value::Object(object).serialize(serializer)
412            }
413            Self::Unknown { tag, value } => {
414                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
415                    return Err(serde::ser::Error::custom(
416                        "unknown union discriminator mismatch",
417                    ));
418                }
419                value.serialize(serializer)
420            }
421        }
422    }
423}
424impl<'de> Deserialize<'de> for StorageAccess {
425    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
426        let value = Value::deserialize(deserializer)?;
427        let tag = value
428            .get("type")
429            .and_then(Value::as_str)
430            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
431        match tag {
432            "signed" => Ok(Self::Signed(
433                serde_json::from_value(
434                    value
435                        .get("signed")
436                        .cloned()
437                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
438                )
439                .map_err(serde::de::Error::custom)?,
440            )),
441            "vended" => Ok(Self::Vended(
442                serde_json::from_value(
443                    value
444                        .get("vended")
445                        .cloned()
446                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
447                )
448                .map_err(serde::de::Error::custom)?,
449            )),
450            tag => Ok(Self::Unknown {
451                tag: tag.to_owned(),
452                value,
453            }),
454        }
455    }
456}
457impl<'de> DeserializeStrict<'de> for StorageAccess {
458    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
459        #[derive(Deserialize)]
460        enum __Tag0 {
461            #[serde(rename = "signed")]
462            Value,
463        }
464        #[derive(Deserialize)]
465        #[serde(deny_unknown_fields)]
466        struct __Arm0 {
467            #[serde(rename = "type")]
468            _tag: __Tag0,
469            #[serde(rename = "signed")]
470            value: Strict<SignedAccess>,
471        }
472        #[derive(Deserialize)]
473        enum __Tag1 {
474            #[serde(rename = "vended")]
475            Value,
476        }
477        #[derive(Deserialize)]
478        #[serde(deny_unknown_fields)]
479        struct __Arm1 {
480            #[serde(rename = "type")]
481            _tag: __Tag1,
482            #[serde(rename = "vended")]
483            value: Strict<VendedAccess>,
484        }
485        #[derive(Deserialize)]
486        #[serde(untagged)]
487        enum __Known {
488            Signed(Box<__Arm0>),
489            Vended(Box<__Arm1>),
490        }
491        Ok(match __Known::deserialize(deserializer)? {
492            __Known::Signed(arm) => Self::Signed(arm.value.0),
493            __Known::Vended(arm) => Self::Vended(arm.value.0),
494        })
495    }
496}
497
498/// StorageAccessRequest contract value.
499#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
500pub struct StorageAccessRequest {
501    /// Contract field mode.
502    #[serde(rename = "mode")]
503    pub mode: StorageMode,
504    /// Contract field write.
505    #[serde(rename = "write")]
506    #[serde(default, skip_serializing_if = "Option::is_none")]
507    pub write: Option<WriteScope>,
508}
509impl<'de> DeserializeStrict<'de> for StorageAccessRequest {
510    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
511        #[derive(Deserialize)]
512        #[serde(deny_unknown_fields)]
513        struct __Wire {
514            #[serde(rename = "mode")]
515            mode: Strict<StorageMode>,
516            #[serde(rename = "write")]
517            #[serde(default)]
518            write: Strict<Option<WriteScope>>,
519        }
520        let wire = __Wire::deserialize(deserializer)?;
521        Ok(Self {
522            mode: wire.mode.0,
523            write: wire.write.0,
524        })
525    }
526}
527
528/// StorageAccessResponse contract value.
529#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
530pub struct StorageAccessResponse {
531    /// Contract field spfsAlias.
532    #[serde(rename = "spfsAlias")]
533    pub spfs_alias: Uuid,
534    /// Contract field spfsToken.
535    #[serde(rename = "spfsToken")]
536    pub spfs_token: SecretToken,
537}
538impl<'de> DeserializeStrict<'de> for StorageAccessResponse {
539    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
540        #[derive(Deserialize)]
541        #[serde(deny_unknown_fields)]
542        struct __Wire {
543            #[serde(rename = "spfsAlias")]
544            spfs_alias: Strict<Uuid>,
545            #[serde(rename = "spfsToken")]
546            spfs_token: Strict<SecretToken>,
547        }
548        let wire = __Wire::deserialize(deserializer)?;
549        Ok(Self {
550            spfs_alias: wire.spfs_alias.0,
551            spfs_token: wire.spfs_token.0,
552        })
553    }
554}
555
556/// StorageBinding contract value.
557#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
558pub struct StorageBinding {
559    /// Contract field access.
560    #[serde(rename = "access")]
561    pub access: StorageAccess,
562    /// Contract field expiresAt.
563    #[serde(rename = "expiresAt")]
564    pub expires_at: SafeUnsignedLong,
565    /// Contract field mode.
566    #[serde(rename = "mode")]
567    pub mode: StorageMode,
568    /// Contract field rootUri.
569    #[serde(rename = "rootUri")]
570    pub root_uri: String,
571}
572impl<'de> DeserializeStrict<'de> for StorageBinding {
573    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
574        #[derive(Deserialize)]
575        #[serde(deny_unknown_fields)]
576        struct __Wire {
577            #[serde(rename = "access")]
578            access: Strict<StorageAccess>,
579            #[serde(rename = "expiresAt")]
580            expires_at: Strict<SafeUnsignedLong>,
581            #[serde(rename = "mode")]
582            mode: Strict<StorageMode>,
583            #[serde(rename = "rootUri")]
584            root_uri: Strict<String>,
585        }
586        let wire = __Wire::deserialize(deserializer)?;
587        Ok(Self {
588            access: wire.access.0,
589            expires_at: wire.expires_at.0,
590            mode: wire.mode.0,
591            root_uri: wire.root_uri.0,
592        })
593    }
594}
595
596/// StorageMode contract value.
597#[derive(Clone, Debug, PartialEq, Eq)]
598pub enum StorageMode {
599    /// A known contract value.
600    ReadOnly,
601    /// A known contract value.
602    ReadWrite,
603    /// A value introduced by a newer server.
604    Unknown(String),
605}
606impl Serialize for StorageMode {
607    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
608        serializer.serialize_str(match self {
609            Self::ReadOnly => "read_only",
610            Self::ReadWrite => "read_write",
611            Self::Unknown(value) => value,
612        })
613    }
614}
615impl<'de> Deserialize<'de> for StorageMode {
616    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
617        Ok(match String::deserialize(deserializer)?.as_str() {
618            "read_only" => Self::ReadOnly,
619            "read_write" => Self::ReadWrite,
620            value => Self::Unknown(value.to_owned()),
621        })
622    }
623}
624impl<'de> DeserializeStrict<'de> for StorageMode {
625    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
626        #[derive(Deserialize)]
627        enum __Known {
628            #[serde(rename = "read_only")]
629            ReadOnly,
630            #[serde(rename = "read_write")]
631            ReadWrite,
632        }
633        Ok(match __Known::deserialize(deserializer)? {
634            __Known::ReadOnly => Self::ReadOnly,
635            __Known::ReadWrite => Self::ReadWrite,
636        })
637    }
638}
639
640/// Stable identity of a Table.
641#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
642#[serde(transparent)]
643pub struct TableId(pub Uuid);
644impl std::fmt::Display for TableId {
645    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
646        self.0.fmt(formatter)
647    }
648}
649impl<'de> DeserializeStrict<'de> for TableId {
650    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
651        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
652    }
653}
654
655/// VendedAccess contract value.
656#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
657pub struct VendedAccess {
658    /// Contract field credential.
659    #[serde(rename = "credential")]
660    pub credential: VendedCredential,
661}
662impl<'de> DeserializeStrict<'de> for VendedAccess {
663    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
664        #[derive(Deserialize)]
665        #[serde(deny_unknown_fields)]
666        struct __Wire {
667            #[serde(rename = "credential")]
668            credential: Strict<VendedCredential>,
669        }
670        let wire = __Wire::deserialize(deserializer)?;
671        Ok(Self {
672            credential: wire.credential.0,
673        })
674    }
675}
676
677/// A short-lived provider credential. Renew it before it expires.
678#[derive(Clone, Debug, PartialEq, Eq)]
679pub enum VendedCredential {
680    /// A known union arm.
681    AwsSession(AwsSession),
682    /// A known union arm.
683    GcsAccessToken(GcsAccessToken),
684    /// A known union arm.
685    HuggingFaceToken(HuggingFaceToken),
686    /// An unknown discriminator and its complete wire object.
687    Unknown { tag: String, value: Value },
688}
689impl Serialize for VendedCredential {
690    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
691        match self {
692            Self::AwsSession(value) => {
693                let mut object = serde_json::Map::new();
694                object.insert("type".into(), Value::String("awsSession".into()));
695                object.insert(
696                    "awsSession".into(),
697                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
698                );
699                Value::Object(object).serialize(serializer)
700            }
701            Self::GcsAccessToken(value) => {
702                let mut object = serde_json::Map::new();
703                object.insert("type".into(), Value::String("gcsAccessToken".into()));
704                object.insert(
705                    "gcsAccessToken".into(),
706                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
707                );
708                Value::Object(object).serialize(serializer)
709            }
710            Self::HuggingFaceToken(value) => {
711                let mut object = serde_json::Map::new();
712                object.insert("type".into(), Value::String("huggingFaceToken".into()));
713                object.insert(
714                    "huggingFaceToken".into(),
715                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
716                );
717                Value::Object(object).serialize(serializer)
718            }
719            Self::Unknown { tag, value } => {
720                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
721                    return Err(serde::ser::Error::custom(
722                        "unknown union discriminator mismatch",
723                    ));
724                }
725                value.serialize(serializer)
726            }
727        }
728    }
729}
730impl<'de> Deserialize<'de> for VendedCredential {
731    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
732        let value = Value::deserialize(deserializer)?;
733        let tag = value
734            .get("type")
735            .and_then(Value::as_str)
736            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
737        match tag {
738            "awsSession" => Ok(Self::AwsSession(
739                serde_json::from_value(
740                    value
741                        .get("awsSession")
742                        .cloned()
743                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
744                )
745                .map_err(serde::de::Error::custom)?,
746            )),
747            "gcsAccessToken" => Ok(Self::GcsAccessToken(
748                serde_json::from_value(
749                    value
750                        .get("gcsAccessToken")
751                        .cloned()
752                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
753                )
754                .map_err(serde::de::Error::custom)?,
755            )),
756            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
757                serde_json::from_value(
758                    value
759                        .get("huggingFaceToken")
760                        .cloned()
761                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
762                )
763                .map_err(serde::de::Error::custom)?,
764            )),
765            tag => Ok(Self::Unknown {
766                tag: tag.to_owned(),
767                value,
768            }),
769        }
770    }
771}
772impl<'de> DeserializeStrict<'de> for VendedCredential {
773    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
774        #[derive(Deserialize)]
775        enum __Tag0 {
776            #[serde(rename = "awsSession")]
777            Value,
778        }
779        #[derive(Deserialize)]
780        #[serde(deny_unknown_fields)]
781        struct __Arm0 {
782            #[serde(rename = "type")]
783            _tag: __Tag0,
784            #[serde(rename = "awsSession")]
785            value: Strict<AwsSession>,
786        }
787        #[derive(Deserialize)]
788        enum __Tag1 {
789            #[serde(rename = "gcsAccessToken")]
790            Value,
791        }
792        #[derive(Deserialize)]
793        #[serde(deny_unknown_fields)]
794        struct __Arm1 {
795            #[serde(rename = "type")]
796            _tag: __Tag1,
797            #[serde(rename = "gcsAccessToken")]
798            value: Strict<GcsAccessToken>,
799        }
800        #[derive(Deserialize)]
801        enum __Tag2 {
802            #[serde(rename = "huggingFaceToken")]
803            Value,
804        }
805        #[derive(Deserialize)]
806        #[serde(deny_unknown_fields)]
807        struct __Arm2 {
808            #[serde(rename = "type")]
809            _tag: __Tag2,
810            #[serde(rename = "huggingFaceToken")]
811            value: Strict<HuggingFaceToken>,
812        }
813        #[derive(Deserialize)]
814        #[serde(untagged)]
815        enum __Known {
816            AwsSession(Box<__Arm0>),
817            GcsAccessToken(Box<__Arm1>),
818            HuggingFaceToken(Box<__Arm2>),
819        }
820        Ok(match __Known::deserialize(deserializer)? {
821            __Known::AwsSession(arm) => Self::AwsSession(arm.value.0),
822            __Known::GcsAccessToken(arm) => Self::GcsAccessToken(arm.value.0),
823            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
824        })
825    }
826}
827
828/// WriteAttempt contract value.
829#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
830pub struct WriteAttempt {
831    /// Contract field attemptId.
832    #[serde(rename = "attemptId")]
833    pub attempt_id: Uuid,
834}
835impl<'de> DeserializeStrict<'de> for WriteAttempt {
836    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
837        #[derive(Deserialize)]
838        #[serde(deny_unknown_fields)]
839        struct __Wire {
840            #[serde(rename = "attemptId")]
841            attempt_id: Strict<Uuid>,
842        }
843        let wire = __Wire::deserialize(deserializer)?;
844        Ok(Self {
845            attempt_id: wire.attempt_id.0,
846        })
847    }
848}
849
850/// WriteScope contract value.
851#[derive(Clone, Debug, PartialEq, Eq)]
852pub enum WriteScope {
853    /// A known union arm.
854    Attempt(WriteAttempt),
855    /// A known union arm.
856    Publication(Empty),
857    /// An unknown discriminator and its complete wire object.
858    Unknown { tag: String, value: Value },
859}
860impl Serialize for WriteScope {
861    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
862        match self {
863            Self::Attempt(value) => {
864                let mut object = serde_json::Map::new();
865                object.insert("type".into(), Value::String("attempt".into()));
866                object.insert(
867                    "attempt".into(),
868                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
869                );
870                Value::Object(object).serialize(serializer)
871            }
872            Self::Publication(value) => {
873                let mut object = serde_json::Map::new();
874                object.insert("type".into(), Value::String("publication".into()));
875                object.insert(
876                    "publication".into(),
877                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
878                );
879                Value::Object(object).serialize(serializer)
880            }
881            Self::Unknown { tag, value } => {
882                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
883                    return Err(serde::ser::Error::custom(
884                        "unknown union discriminator mismatch",
885                    ));
886                }
887                value.serialize(serializer)
888            }
889        }
890    }
891}
892impl<'de> Deserialize<'de> for WriteScope {
893    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
894        let value = Value::deserialize(deserializer)?;
895        let tag = value
896            .get("type")
897            .and_then(Value::as_str)
898            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
899        match tag {
900            "attempt" => Ok(Self::Attempt(
901                serde_json::from_value(
902                    value
903                        .get("attempt")
904                        .cloned()
905                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
906                )
907                .map_err(serde::de::Error::custom)?,
908            )),
909            "publication" => Ok(Self::Publication(
910                serde_json::from_value(
911                    value
912                        .get("publication")
913                        .cloned()
914                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
915                )
916                .map_err(serde::de::Error::custom)?,
917            )),
918            tag => Ok(Self::Unknown {
919                tag: tag.to_owned(),
920                value,
921            }),
922        }
923    }
924}
925impl<'de> DeserializeStrict<'de> for WriteScope {
926    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
927        #[derive(Deserialize)]
928        enum __Tag0 {
929            #[serde(rename = "attempt")]
930            Value,
931        }
932        #[derive(Deserialize)]
933        #[serde(deny_unknown_fields)]
934        struct __Arm0 {
935            #[serde(rename = "type")]
936            _tag: __Tag0,
937            #[serde(rename = "attempt")]
938            value: Strict<WriteAttempt>,
939        }
940        #[derive(Deserialize)]
941        enum __Tag1 {
942            #[serde(rename = "publication")]
943            Value,
944        }
945        #[derive(Deserialize)]
946        #[serde(deny_unknown_fields)]
947        struct __Arm1 {
948            #[serde(rename = "type")]
949            _tag: __Tag1,
950            #[serde(rename = "publication")]
951            value: Strict<Empty>,
952        }
953        #[derive(Deserialize)]
954        #[serde(untagged)]
955        enum __Known {
956            Attempt(Box<__Arm0>),
957            Publication(Box<__Arm1>),
958        }
959        Ok(match __Known::deserialize(deserializer)? {
960            __Known::Attempt(arm) => Self::Attempt(arm.value.0),
961            __Known::Publication(arm) => Self::Publication(arm.value.0),
962        })
963    }
964}
965
966/// Typed errors declared by this service contract.
967#[derive(Clone, Debug, PartialEq, Eq)]
968pub enum TablesError {
969    /// Tables:Conflict.
970    Conflict { reason: String },
971    /// Tables:InvalidArgument.
972    InvalidArgument { reason: String },
973    /// Tables:NotFound.
974    NotFound { resource: String },
975}
976impl TablesError {
977    /// HTTP status for this declared error.
978    pub fn status(&self) -> u16 {
979        match self {
980            Self::Conflict { .. } => 409,
981            Self::InvalidArgument { .. } => 400,
982            Self::NotFound { .. } => 404,
983        }
984    }
985    /// Serialize only contract-declared error parameters.
986    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
987        match self {
988            Self::Conflict { reason } => {
989                let mut envelope = ErrorEnvelope::new("CONFLICT", "Tables:Conflict", instance);
990                envelope
991                    .parameters
992                    .insert("reason".into(), reason.to_string());
993                envelope
994            }
995            Self::InvalidArgument { reason } => {
996                let mut envelope =
997                    ErrorEnvelope::new("INVALID_ARGUMENT", "Tables:InvalidArgument", instance);
998                envelope
999                    .parameters
1000                    .insert("reason".into(), reason.to_string());
1001                envelope
1002            }
1003            Self::NotFound { resource } => {
1004                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Tables:NotFound", instance);
1005                envelope
1006                    .parameters
1007                    .insert("resource".into(), resource.to_string());
1008                envelope
1009            }
1010        }
1011    }
1012    /// Decode a declared error and its typed error parameters.
1013    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
1014        if envelope.error_instance_id.len() != 36
1015            || Uuid::parse_str(&envelope.error_instance_id).is_err()
1016        {
1017            return None;
1018        }
1019        match envelope.error_name.as_str() {
1020            "Tables:Conflict" => {
1021                if envelope.error_code != "CONFLICT" {
1022                    return None;
1023                }
1024                let reason = envelope.parameters.get("reason")?.clone();
1025                Some(Self::Conflict { reason })
1026            }
1027            "Tables:InvalidArgument" => {
1028                if envelope.error_code != "INVALID_ARGUMENT" {
1029                    return None;
1030                }
1031                let reason = envelope.parameters.get("reason")?.clone();
1032                Some(Self::InvalidArgument { reason })
1033            }
1034            "Tables:NotFound" => {
1035                if envelope.error_code != "NOT_FOUND" {
1036                    return None;
1037                }
1038                let resource = envelope.parameters.get("resource")?.clone();
1039                Some(Self::NotFound { resource })
1040            }
1041            _ => None,
1042        }
1043    }
1044}
1045impl Display for TablesError {
1046    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1047        match self {
1048            Self::Conflict { reason } => write!(formatter, "Tables:Conflict (reason: {})", reason),
1049            Self::InvalidArgument { reason } => {
1050                write!(formatter, "Tables:InvalidArgument (reason: {})", reason)
1051            }
1052            Self::NotFound { resource } => {
1053                write!(formatter, "Tables:NotFound (resource: {})", resource)
1054            }
1055        }
1056    }
1057}
1058impl StdError for TablesError {}
1059impl ServiceError for TablesError {
1060    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
1061        Self::envelope(self, instance)
1062    }
1063    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
1064        Self::decode_envelope(envelope)
1065    }
1066}
spiral/api/tables/objects.rs

spiral/api/tables/
objects.rs
