spiral/api/vector_indexes/
objects.rs

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

spiral/api/vector_indexes/
objects.rs
