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

spiral/api/locations/
objects.rs
