spiral/api/organization/
objects.rs

1// Generated by tools/service-contracts/rust.py. Do not edit.
2#![doc = "Generated transport-independent contract objects."]
3
4use std::error::Error as StdError;
5use std::fmt::{self, Display, Formatter};
6
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8use serde_json::Value;
9use spiral_contract::error::{ErrorEnvelope, ServiceError};
10use spiral_contract::strict::{DeserializeStrict, Strict};
11use uuid::Uuid;
12
13/// A plaintext request credential or a stored vault reference.
14#[derive(Clone, Debug, PartialEq, Eq)]
15pub enum AccessKey {
16    /// A known union arm.
17    Secret(String),
18    /// A known union arm.
19    Token(SecretToken),
20    /// An unknown discriminator and its complete wire object.
21    Unknown { tag: String, value: Value },
22}
23impl Serialize for AccessKey {
24    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
25        match self {
26            Self::Secret(value) => {
27                let mut object = serde_json::Map::new();
28                object.insert("type".into(), Value::String("secret".into()));
29                object.insert(
30                    "secret".into(),
31                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
32                );
33                Value::Object(object).serialize(serializer)
34            }
35            Self::Token(value) => {
36                let mut object = serde_json::Map::new();
37                object.insert("type".into(), Value::String("token".into()));
38                object.insert(
39                    "token".into(),
40                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
41                );
42                Value::Object(object).serialize(serializer)
43            }
44            Self::Unknown { tag, value } => {
45                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
46                    return Err(serde::ser::Error::custom(
47                        "unknown union discriminator mismatch",
48                    ));
49                }
50                value.serialize(serializer)
51            }
52        }
53    }
54}
55impl<'de> Deserialize<'de> for AccessKey {
56    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
57        let value = Value::deserialize(deserializer)?;
58        let tag = value
59            .get("type")
60            .and_then(Value::as_str)
61            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
62        match tag {
63            "secret" => Ok(Self::Secret(
64                serde_json::from_value(
65                    value
66                        .get("secret")
67                        .cloned()
68                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
69                )
70                .map_err(serde::de::Error::custom)?,
71            )),
72            "token" => Ok(Self::Token(
73                serde_json::from_value(
74                    value
75                        .get("token")
76                        .cloned()
77                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
78                )
79                .map_err(serde::de::Error::custom)?,
80            )),
81            tag => Ok(Self::Unknown {
82                tag: tag.to_owned(),
83                value,
84            }),
85        }
86    }
87}
88impl<'de> DeserializeStrict<'de> for AccessKey {
89    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
90        #[derive(Deserialize)]
91        enum __Tag0 {
92            #[serde(rename = "secret")]
93            Value,
94        }
95        #[derive(Deserialize)]
96        #[serde(deny_unknown_fields)]
97        struct __Arm0 {
98            #[serde(rename = "type")]
99            _tag: __Tag0,
100            #[serde(rename = "secret")]
101            value: Strict<String>,
102        }
103        #[derive(Deserialize)]
104        enum __Tag1 {
105            #[serde(rename = "token")]
106            Value,
107        }
108        #[derive(Deserialize)]
109        #[serde(deny_unknown_fields)]
110        struct __Arm1 {
111            #[serde(rename = "type")]
112            _tag: __Tag1,
113            #[serde(rename = "token")]
114            value: Strict<SecretToken>,
115        }
116        #[derive(Deserialize)]
117        #[serde(untagged)]
118        enum __Known {
119            Secret(Box<__Arm0>),
120            Token(Box<__Arm1>),
121        }
122        Ok(match __Known::deserialize(deserializer)? {
123            __Known::Secret(arm) => Self::Secret(arm.value.0),
124            __Known::Token(arm) => Self::Token(arm.value.0),
125        })
126    }
127}
128
129/// How a member signs in. Unclassified means the provider cannot classify the available history.
130#[derive(Clone, Debug, PartialEq, Eq)]
131pub enum AuthenticationMethod {
132    /// A known contract value.
133    Directory,
134    /// A known contract value.
135    Sso,
136    /// A known contract value.
137    Password,
138    /// A known contract value.
139    Unclassified,
140    /// A value introduced by a newer server.
141    Unknown(String),
142}
143impl Serialize for AuthenticationMethod {
144    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
145        serializer.serialize_str(match self {
146            Self::Directory => "directory",
147            Self::Sso => "sso",
148            Self::Password => "password",
149            Self::Unclassified => "unclassified",
150            Self::Unknown(value) => value,
151        })
152    }
153}
154impl<'de> Deserialize<'de> for AuthenticationMethod {
155    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
156        Ok(match String::deserialize(deserializer)?.as_str() {
157            "directory" => Self::Directory,
158            "sso" => Self::Sso,
159            "password" => Self::Password,
160            "unclassified" => Self::Unclassified,
161            value => Self::Unknown(value.to_owned()),
162        })
163    }
164}
165impl<'de> DeserializeStrict<'de> for AuthenticationMethod {
166    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
167        #[derive(Deserialize)]
168        enum __Known {
169            #[serde(rename = "directory")]
170            Directory,
171            #[serde(rename = "sso")]
172            Sso,
173            #[serde(rename = "password")]
174            Password,
175            #[serde(rename = "unclassified")]
176            Unclassified,
177        }
178        Ok(match __Known::deserialize(deserializer)? {
179            __Known::Directory => Self::Directory,
180            __Known::Sso => Self::Sso,
181            __Known::Password => Self::Password,
182            __Known::Unclassified => Self::Unclassified,
183        })
184    }
185}
186
187/// An operator-configured managed storage provider.
188#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
189pub struct BuiltinStorage {
190    /// Contract field directory.
191    #[serde(rename = "directory")]
192    pub directory: String,
193    /// Contract field provider.
194    #[serde(rename = "provider")]
195    pub provider: String,
196}
197impl<'de> DeserializeStrict<'de> for BuiltinStorage {
198    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
199        #[derive(Deserialize)]
200        #[serde(deny_unknown_fields)]
201        struct __Wire {
202            #[serde(rename = "directory")]
203            directory: Strict<String>,
204            #[serde(rename = "provider")]
205            provider: Strict<String>,
206        }
207        let wire = __Wire::deserialize(deserializer)?;
208        Ok(Self {
209            directory: wire.directory.0,
210            provider: wire.provider.0,
211        })
212    }
213}
214
215/// An optional Organization name; absent names are generated.
216#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
217pub struct CreateOrganizationRequest {
218    /// Contract field name.
219    #[serde(rename = "name")]
220    #[serde(default, skip_serializing_if = "Option::is_none")]
221    pub name: Option<String>,
222}
223impl<'de> DeserializeStrict<'de> for CreateOrganizationRequest {
224    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
225        #[derive(Deserialize)]
226        #[serde(deny_unknown_fields)]
227        struct __Wire {
228            #[serde(rename = "name")]
229            #[serde(default)]
230            name: Strict<Option<String>>,
231        }
232        let wire = __Wire::deserialize(deserializer)?;
233        Ok(Self { name: wire.name.0 })
234    }
235}
236
237/// The Organization created in the identity provider. Webhook synchronization creates local
238/// membership state.
239#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
240pub struct CreateOrganizationResponse {
241    /// Contract field organization.
242    #[serde(rename = "organization")]
243    pub organization: Organization,
244}
245impl<'de> DeserializeStrict<'de> for CreateOrganizationResponse {
246    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
247        #[derive(Deserialize)]
248        #[serde(deny_unknown_fields)]
249        struct __Wire {
250            #[serde(rename = "organization")]
251            organization: Strict<Organization>,
252        }
253        let wire = __Wire::deserialize(deserializer)?;
254        Ok(Self {
255            organization: wire.organization.0,
256        })
257    }
258}
259
260/// Storage for newly created Projects. Changing this default does not move existing Projects.
261#[derive(Clone, Debug, PartialEq, Eq)]
262pub enum DefaultFilesystem {
263    /// A known union arm.
264    Disabled(Empty),
265    /// A known union arm.
266    Filesystem(Filesystem),
267    /// A known union arm.
268    Managed(Empty),
269    /// An unknown discriminator and its complete wire object.
270    Unknown { tag: String, value: Value },
271}
272impl Serialize for DefaultFilesystem {
273    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
274        match self {
275            Self::Disabled(value) => {
276                let mut object = serde_json::Map::new();
277                object.insert("type".into(), Value::String("disabled".into()));
278                object.insert(
279                    "disabled".into(),
280                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
281                );
282                Value::Object(object).serialize(serializer)
283            }
284            Self::Filesystem(value) => {
285                let mut object = serde_json::Map::new();
286                object.insert("type".into(), Value::String("filesystem".into()));
287                object.insert(
288                    "filesystem".into(),
289                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
290                );
291                Value::Object(object).serialize(serializer)
292            }
293            Self::Managed(value) => {
294                let mut object = serde_json::Map::new();
295                object.insert("type".into(), Value::String("managed".into()));
296                object.insert(
297                    "managed".into(),
298                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
299                );
300                Value::Object(object).serialize(serializer)
301            }
302            Self::Unknown { tag, value } => {
303                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
304                    return Err(serde::ser::Error::custom(
305                        "unknown union discriminator mismatch",
306                    ));
307                }
308                value.serialize(serializer)
309            }
310        }
311    }
312}
313impl<'de> Deserialize<'de> for DefaultFilesystem {
314    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
315        let value = Value::deserialize(deserializer)?;
316        let tag = value
317            .get("type")
318            .and_then(Value::as_str)
319            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
320        match tag {
321            "disabled" => Ok(Self::Disabled(
322                serde_json::from_value(
323                    value
324                        .get("disabled")
325                        .cloned()
326                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
327                )
328                .map_err(serde::de::Error::custom)?,
329            )),
330            "filesystem" => Ok(Self::Filesystem(
331                serde_json::from_value(
332                    value
333                        .get("filesystem")
334                        .cloned()
335                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
336                )
337                .map_err(serde::de::Error::custom)?,
338            )),
339            "managed" => Ok(Self::Managed(
340                serde_json::from_value(
341                    value
342                        .get("managed")
343                        .cloned()
344                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
345                )
346                .map_err(serde::de::Error::custom)?,
347            )),
348            tag => Ok(Self::Unknown {
349                tag: tag.to_owned(),
350                value,
351            }),
352        }
353    }
354}
355impl<'de> DeserializeStrict<'de> for DefaultFilesystem {
356    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
357        #[derive(Deserialize)]
358        enum __Tag0 {
359            #[serde(rename = "disabled")]
360            Value,
361        }
362        #[derive(Deserialize)]
363        #[serde(deny_unknown_fields)]
364        struct __Arm0 {
365            #[serde(rename = "type")]
366            _tag: __Tag0,
367            #[serde(rename = "disabled")]
368            value: Strict<Empty>,
369        }
370        #[derive(Deserialize)]
371        enum __Tag1 {
372            #[serde(rename = "filesystem")]
373            Value,
374        }
375        #[derive(Deserialize)]
376        #[serde(deny_unknown_fields)]
377        struct __Arm1 {
378            #[serde(rename = "type")]
379            _tag: __Tag1,
380            #[serde(rename = "filesystem")]
381            value: Strict<Filesystem>,
382        }
383        #[derive(Deserialize)]
384        enum __Tag2 {
385            #[serde(rename = "managed")]
386            Value,
387        }
388        #[derive(Deserialize)]
389        #[serde(deny_unknown_fields)]
390        struct __Arm2 {
391            #[serde(rename = "type")]
392            _tag: __Tag2,
393            #[serde(rename = "managed")]
394            value: Strict<Empty>,
395        }
396        #[derive(Deserialize)]
397        #[serde(untagged)]
398        enum __Known {
399            Disabled(Box<__Arm0>),
400            Filesystem(Box<__Arm1>),
401            Managed(Box<__Arm2>),
402        }
403        Ok(match __Known::deserialize(deserializer)? {
404            __Known::Disabled(arm) => Self::Disabled(arm.value.0),
405            __Known::Filesystem(arm) => Self::Filesystem(arm.value.0),
406            __Known::Managed(arm) => Self::Managed(arm.value.0),
407        })
408    }
409}
410
411/// No additional configuration.
412#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
413pub struct Empty {}
414impl<'de> DeserializeStrict<'de> for Empty {
415    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
416        #[derive(Deserialize)]
417        #[serde(deny_unknown_fields)]
418        struct __Wire {}
419        __Wire::deserialize(deserializer)?;
420        Ok(Self {})
421    }
422}
423
424/// A typed storage template. Storage validation and secret handling remain storage-service
425/// operations.
426#[derive(Clone, Debug, PartialEq, Eq)]
427pub enum Filesystem {
428    /// A known union arm.
429    Builtin(BuiltinStorage),
430    /// A known union arm.
431    Gcs(GcsStorage),
432    /// A known union arm.
433    R2(R2Storage),
434    /// A known union arm.
435    S3(S3Storage),
436    /// A known union arm.
437    S3Compatible(S3CompatibleStorage),
438    /// A known union arm.
439    Upstream(UpstreamStorage),
440    /// An unknown discriminator and its complete wire object.
441    Unknown { tag: String, value: Value },
442}
443impl Serialize for Filesystem {
444    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
445        match self {
446            Self::Builtin(value) => {
447                let mut object = serde_json::Map::new();
448                object.insert("type".into(), Value::String("builtin".into()));
449                object.insert(
450                    "builtin".into(),
451                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
452                );
453                Value::Object(object).serialize(serializer)
454            }
455            Self::Gcs(value) => {
456                let mut object = serde_json::Map::new();
457                object.insert("type".into(), Value::String("gcs".into()));
458                object.insert(
459                    "gcs".into(),
460                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
461                );
462                Value::Object(object).serialize(serializer)
463            }
464            Self::R2(value) => {
465                let mut object = serde_json::Map::new();
466                object.insert("type".into(), Value::String("r2".into()));
467                object.insert(
468                    "r2".into(),
469                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
470                );
471                Value::Object(object).serialize(serializer)
472            }
473            Self::S3(value) => {
474                let mut object = serde_json::Map::new();
475                object.insert("type".into(), Value::String("s3".into()));
476                object.insert(
477                    "s3".into(),
478                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
479                );
480                Value::Object(object).serialize(serializer)
481            }
482            Self::S3Compatible(value) => {
483                let mut object = serde_json::Map::new();
484                object.insert("type".into(), Value::String("s3Compatible".into()));
485                object.insert(
486                    "s3Compatible".into(),
487                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
488                );
489                Value::Object(object).serialize(serializer)
490            }
491            Self::Upstream(value) => {
492                let mut object = serde_json::Map::new();
493                object.insert("type".into(), Value::String("upstream".into()));
494                object.insert(
495                    "upstream".into(),
496                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
497                );
498                Value::Object(object).serialize(serializer)
499            }
500            Self::Unknown { tag, value } => {
501                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
502                    return Err(serde::ser::Error::custom(
503                        "unknown union discriminator mismatch",
504                    ));
505                }
506                value.serialize(serializer)
507            }
508        }
509    }
510}
511impl<'de> Deserialize<'de> for Filesystem {
512    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
513        let value = Value::deserialize(deserializer)?;
514        let tag = value
515            .get("type")
516            .and_then(Value::as_str)
517            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
518        match tag {
519            "builtin" => Ok(Self::Builtin(
520                serde_json::from_value(
521                    value
522                        .get("builtin")
523                        .cloned()
524                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
525                )
526                .map_err(serde::de::Error::custom)?,
527            )),
528            "gcs" => Ok(Self::Gcs(
529                serde_json::from_value(
530                    value
531                        .get("gcs")
532                        .cloned()
533                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
534                )
535                .map_err(serde::de::Error::custom)?,
536            )),
537            "r2" => Ok(Self::R2(
538                serde_json::from_value(
539                    value
540                        .get("r2")
541                        .cloned()
542                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
543                )
544                .map_err(serde::de::Error::custom)?,
545            )),
546            "s3" => Ok(Self::S3(
547                serde_json::from_value(
548                    value
549                        .get("s3")
550                        .cloned()
551                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
552                )
553                .map_err(serde::de::Error::custom)?,
554            )),
555            "s3Compatible" => Ok(Self::S3Compatible(
556                serde_json::from_value(
557                    value
558                        .get("s3Compatible")
559                        .cloned()
560                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
561                )
562                .map_err(serde::de::Error::custom)?,
563            )),
564            "upstream" => Ok(Self::Upstream(
565                serde_json::from_value(
566                    value
567                        .get("upstream")
568                        .cloned()
569                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
570                )
571                .map_err(serde::de::Error::custom)?,
572            )),
573            tag => Ok(Self::Unknown {
574                tag: tag.to_owned(),
575                value,
576            }),
577        }
578    }
579}
580impl<'de> DeserializeStrict<'de> for Filesystem {
581    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
582        #[derive(Deserialize)]
583        enum __Tag0 {
584            #[serde(rename = "builtin")]
585            Value,
586        }
587        #[derive(Deserialize)]
588        #[serde(deny_unknown_fields)]
589        struct __Arm0 {
590            #[serde(rename = "type")]
591            _tag: __Tag0,
592            #[serde(rename = "builtin")]
593            value: Strict<BuiltinStorage>,
594        }
595        #[derive(Deserialize)]
596        enum __Tag1 {
597            #[serde(rename = "gcs")]
598            Value,
599        }
600        #[derive(Deserialize)]
601        #[serde(deny_unknown_fields)]
602        struct __Arm1 {
603            #[serde(rename = "type")]
604            _tag: __Tag1,
605            #[serde(rename = "gcs")]
606            value: Strict<GcsStorage>,
607        }
608        #[derive(Deserialize)]
609        enum __Tag2 {
610            #[serde(rename = "r2")]
611            Value,
612        }
613        #[derive(Deserialize)]
614        #[serde(deny_unknown_fields)]
615        struct __Arm2 {
616            #[serde(rename = "type")]
617            _tag: __Tag2,
618            #[serde(rename = "r2")]
619            value: Strict<R2Storage>,
620        }
621        #[derive(Deserialize)]
622        enum __Tag3 {
623            #[serde(rename = "s3")]
624            Value,
625        }
626        #[derive(Deserialize)]
627        #[serde(deny_unknown_fields)]
628        struct __Arm3 {
629            #[serde(rename = "type")]
630            _tag: __Tag3,
631            #[serde(rename = "s3")]
632            value: Strict<S3Storage>,
633        }
634        #[derive(Deserialize)]
635        enum __Tag4 {
636            #[serde(rename = "s3Compatible")]
637            Value,
638        }
639        #[derive(Deserialize)]
640        #[serde(deny_unknown_fields)]
641        struct __Arm4 {
642            #[serde(rename = "type")]
643            _tag: __Tag4,
644            #[serde(rename = "s3Compatible")]
645            value: Strict<S3CompatibleStorage>,
646        }
647        #[derive(Deserialize)]
648        enum __Tag5 {
649            #[serde(rename = "upstream")]
650            Value,
651        }
652        #[derive(Deserialize)]
653        #[serde(deny_unknown_fields)]
654        struct __Arm5 {
655            #[serde(rename = "type")]
656            _tag: __Tag5,
657            #[serde(rename = "upstream")]
658            value: Strict<UpstreamStorage>,
659        }
660        #[derive(Deserialize)]
661        #[serde(untagged)]
662        enum __Known {
663            Builtin(Box<__Arm0>),
664            Gcs(Box<__Arm1>),
665            R2(Box<__Arm2>),
666            S3(Box<__Arm3>),
667            S3Compatible(Box<__Arm4>),
668            Upstream(Box<__Arm5>),
669        }
670        Ok(match __Known::deserialize(deserializer)? {
671            __Known::Builtin(arm) => Self::Builtin(arm.value.0),
672            __Known::Gcs(arm) => Self::Gcs(arm.value.0),
673            __Known::R2(arm) => Self::R2(arm.value.0),
674            __Known::S3(arm) => Self::S3(arm.value.0),
675            __Known::S3Compatible(arm) => Self::S3Compatible(arm.value.0),
676            __Known::Upstream(arm) => Self::Upstream(arm.value.0),
677        })
678    }
679}
680
681/// An existing Google Cloud Storage template. New templates remain subject to the storage service
682/// policy.
683#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
684pub struct GcsStorage {
685    /// Contract field bucket.
686    #[serde(rename = "bucket")]
687    pub bucket: String,
688    /// Contract field directory.
689    #[serde(rename = "directory")]
690    pub directory: String,
691    /// Contract field region.
692    #[serde(rename = "region")]
693    pub region: String,
694}
695impl<'de> DeserializeStrict<'de> for GcsStorage {
696    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
697        #[derive(Deserialize)]
698        #[serde(deny_unknown_fields)]
699        struct __Wire {
700            #[serde(rename = "bucket")]
701            bucket: Strict<String>,
702            #[serde(rename = "directory")]
703            directory: Strict<String>,
704            #[serde(rename = "region")]
705            region: Strict<String>,
706        }
707        let wire = __Wire::deserialize(deserializer)?;
708        Ok(Self {
709            bucket: wire.bucket.0,
710            directory: wire.directory.0,
711            region: wire.region.0,
712        })
713    }
714}
715
716/// The authenticated user and active Organization. Requires a first-party user credential.
717#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
718pub struct Identity {
719    /// Contract field email.
720    #[serde(rename = "email")]
721    pub email: String,
722    /// Contract field emailVerified.
723    #[serde(rename = "emailVerified")]
724    pub email_verified: bool,
725    /// Contract field firstName.
726    #[serde(rename = "firstName")]
727    pub first_name: String,
728    /// Contract field lastName.
729    #[serde(rename = "lastName")]
730    pub last_name: String,
731    /// Contract field organizationId.
732    #[serde(rename = "organizationId")]
733    pub organization_id: String,
734    /// Contract field organizationName.
735    #[serde(rename = "organizationName")]
736    #[serde(default, skip_serializing_if = "Option::is_none")]
737    pub organization_name: Option<String>,
738    /// Contract field role.
739    #[serde(rename = "role")]
740    #[serde(default, skip_serializing_if = "Option::is_none")]
741    pub role: Option<String>,
742    /// Contract field userId.
743    #[serde(rename = "userId")]
744    pub user_id: String,
745}
746impl<'de> DeserializeStrict<'de> for Identity {
747    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
748        #[derive(Deserialize)]
749        #[serde(deny_unknown_fields)]
750        struct __Wire {
751            #[serde(rename = "email")]
752            email: Strict<String>,
753            #[serde(rename = "emailVerified")]
754            email_verified: Strict<bool>,
755            #[serde(rename = "firstName")]
756            first_name: Strict<String>,
757            #[serde(rename = "lastName")]
758            last_name: Strict<String>,
759            #[serde(rename = "organizationId")]
760            organization_id: Strict<String>,
761            #[serde(rename = "organizationName")]
762            #[serde(default)]
763            organization_name: Strict<Option<String>>,
764            #[serde(rename = "role")]
765            #[serde(default)]
766            role: Strict<Option<String>>,
767            #[serde(rename = "userId")]
768            user_id: Strict<String>,
769        }
770        let wire = __Wire::deserialize(deserializer)?;
771        Ok(Self {
772            email: wire.email.0,
773            email_verified: wire.email_verified.0,
774            first_name: wire.first_name.0,
775            last_name: wire.last_name.0,
776            organization_id: wire.organization_id.0,
777            organization_name: wire.organization_name.0,
778            role: wire.role.0,
779            user_id: wire.user_id.0,
780        })
781    }
782}
783
784/// An invitation owned by the active Organization.
785#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
786pub struct Invitation {
787    /// Contract field acceptedAt.
788    #[serde(rename = "acceptedAt")]
789    #[serde(default, skip_serializing_if = "Option::is_none")]
790    pub accepted_at: Option<String>,
791    /// Contract field createdAt.
792    #[serde(rename = "createdAt")]
793    #[serde(default, skip_serializing_if = "Option::is_none")]
794    pub created_at: Option<String>,
795    /// Contract field email.
796    #[serde(rename = "email")]
797    pub email: String,
798    /// Contract field expiresAt.
799    #[serde(rename = "expiresAt")]
800    #[serde(default, skip_serializing_if = "Option::is_none")]
801    pub expires_at: Option<String>,
802    /// Contract field id.
803    #[serde(rename = "id")]
804    pub id: String,
805    /// Contract field inviterUserId.
806    #[serde(rename = "inviterUserId")]
807    #[serde(default, skip_serializing_if = "Option::is_none")]
808    pub inviter_user_id: Option<String>,
809    /// Contract field role.
810    #[serde(rename = "role")]
811    #[serde(default, skip_serializing_if = "Option::is_none")]
812    pub role: Option<OrganizationRole>,
813    /// Contract field state.
814    #[serde(rename = "state")]
815    pub state: String,
816}
817impl<'de> DeserializeStrict<'de> for Invitation {
818    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
819        #[derive(Deserialize)]
820        #[serde(deny_unknown_fields)]
821        struct __Wire {
822            #[serde(rename = "acceptedAt")]
823            #[serde(default)]
824            accepted_at: Strict<Option<String>>,
825            #[serde(rename = "createdAt")]
826            #[serde(default)]
827            created_at: Strict<Option<String>>,
828            #[serde(rename = "email")]
829            email: Strict<String>,
830            #[serde(rename = "expiresAt")]
831            #[serde(default)]
832            expires_at: Strict<Option<String>>,
833            #[serde(rename = "id")]
834            id: Strict<String>,
835            #[serde(rename = "inviterUserId")]
836            #[serde(default)]
837            inviter_user_id: Strict<Option<String>>,
838            #[serde(rename = "role")]
839            #[serde(default)]
840            role: Strict<Option<OrganizationRole>>,
841            #[serde(rename = "state")]
842            state: Strict<String>,
843        }
844        let wire = __Wire::deserialize(deserializer)?;
845        Ok(Self {
846            accepted_at: wire.accepted_at.0,
847            created_at: wire.created_at.0,
848            email: wire.email.0,
849            expires_at: wire.expires_at.0,
850            id: wire.id.0,
851            inviter_user_id: wire.inviter_user_id.0,
852            role: wire.role.0,
853            state: wire.state.0,
854        })
855    }
856}
857
858/// Live invitations in descending provider invitation ID order.
859#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
860pub struct InvitationPage {
861    /// Contract field items.
862    #[serde(rename = "items")]
863    pub items: Vec<Invitation>,
864    /// Contract field nextPageToken.
865    #[serde(rename = "nextPageToken")]
866    #[serde(default, skip_serializing_if = "Option::is_none")]
867    pub next_page_token: Option<String>,
868}
869impl<'de> DeserializeStrict<'de> for InvitationPage {
870    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
871        #[derive(Deserialize)]
872        #[serde(deny_unknown_fields)]
873        struct __Wire {
874            #[serde(rename = "items")]
875            items: Strict<Vec<Invitation>>,
876            #[serde(rename = "nextPageToken")]
877            #[serde(default)]
878            next_page_token: Strict<Option<String>>,
879        }
880        let wire = __Wire::deserialize(deserializer)?;
881        Ok(Self {
882            items: wire.items.0,
883            next_page_token: wire.next_page_token.0,
884        })
885    }
886}
887
888/// The provider invitation identity.
889#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
890pub struct InvitationResponse {
891    /// Contract field invitationId.
892    #[serde(rename = "invitationId")]
893    pub invitation_id: String,
894}
895impl<'de> DeserializeStrict<'de> for InvitationResponse {
896    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
897        #[derive(Deserialize)]
898        #[serde(deny_unknown_fields)]
899        struct __Wire {
900            #[serde(rename = "invitationId")]
901            invitation_id: Strict<String>,
902        }
903        let wire = __Wire::deserialize(deserializer)?;
904        Ok(Self {
905            invitation_id: wire.invitation_id.0,
906        })
907    }
908}
909
910/// Invite a user with an Organization role and optional invitation lifetime.
911#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
912pub struct InviteMemberRequest {
913    /// Contract field email.
914    #[serde(rename = "email")]
915    pub email: String,
916    /// Contract field expiresInDays.
917    #[serde(rename = "expiresInDays")]
918    #[serde(default, skip_serializing_if = "Option::is_none")]
919    pub expires_in_days: Option<i32>,
920    /// Contract field role.
921    #[serde(rename = "role")]
922    pub role: OrganizationRole,
923}
924impl<'de> DeserializeStrict<'de> for InviteMemberRequest {
925    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
926        #[derive(Deserialize)]
927        #[serde(deny_unknown_fields)]
928        struct __Wire {
929            #[serde(rename = "email")]
930            email: Strict<String>,
931            #[serde(rename = "expiresInDays")]
932            #[serde(default)]
933            expires_in_days: Strict<Option<i32>>,
934            #[serde(rename = "role")]
935            role: Strict<OrganizationRole>,
936        }
937        let wire = __Wire::deserialize(deserializer)?;
938        Ok(Self {
939            email: wire.email.0,
940            expires_in_days: wire.expires_in_days.0,
941            role: wire.role.0,
942        })
943    }
944}
945
946/// Live provider membership listing in descending provider membership ID order. Page size defaults
947/// to 10 and must be 1..=100. Continuations expire after one hour and bind the credential and page
948/// size.
949#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
950pub struct ListMembersRequest {
951    /// Contract field pageSize.
952    #[serde(rename = "pageSize")]
953    #[serde(default, skip_serializing_if = "Option::is_none")]
954    pub page_size: Option<u32>,
955    /// Contract field pageToken.
956    #[serde(rename = "pageToken")]
957    #[serde(default, skip_serializing_if = "Option::is_none")]
958    pub page_token: Option<String>,
959}
960impl<'de> DeserializeStrict<'de> for ListMembersRequest {
961    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
962        #[derive(Deserialize)]
963        #[serde(deny_unknown_fields)]
964        struct __Wire {
965            #[serde(rename = "pageSize")]
966            #[serde(default)]
967            page_size: Strict<Option<u32>>,
968            #[serde(rename = "pageToken")]
969            #[serde(default)]
970            page_token: Strict<Option<String>>,
971        }
972        let wire = __Wire::deserialize(deserializer)?;
973        Ok(Self {
974            page_size: wire.page_size.0,
975            page_token: wire.page_token.0,
976        })
977    }
978}
979
980/// Live continuation request. Page size defaults to 100 and must be 1..=1000. Tokens expire after
981/// one hour and are bound to the credential, operation, filters and page size.
982#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
983pub struct ListMembershipsRequest {
984    /// Contract field pageSize.
985    #[serde(rename = "pageSize")]
986    #[serde(default, skip_serializing_if = "Option::is_none")]
987    pub page_size: Option<u32>,
988    /// Contract field pageToken.
989    #[serde(rename = "pageToken")]
990    #[serde(default, skip_serializing_if = "Option::is_none")]
991    pub page_token: Option<String>,
992}
993impl<'de> DeserializeStrict<'de> for ListMembershipsRequest {
994    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
995        #[derive(Deserialize)]
996        #[serde(deny_unknown_fields)]
997        struct __Wire {
998            #[serde(rename = "pageSize")]
999            #[serde(default)]
1000            page_size: Strict<Option<u32>>,
1001            #[serde(rename = "pageToken")]
1002            #[serde(default)]
1003            page_token: Strict<Option<String>>,
1004        }
1005        let wire = __Wire::deserialize(deserializer)?;
1006        Ok(Self {
1007            page_size: wire.page_size.0,
1008            page_token: wire.page_token.0,
1009        })
1010    }
1011}
1012
1013/// Filter Organizations by active status. Page size defaults to 100 and must be 1..=1000.
1014#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1015pub struct ListOrganizationsRequest {
1016    /// Contract field active.
1017    #[serde(rename = "active")]
1018    #[serde(default, skip_serializing_if = "Option::is_none")]
1019    pub active: Option<bool>,
1020    /// Contract field pageSize.
1021    #[serde(rename = "pageSize")]
1022    #[serde(default, skip_serializing_if = "Option::is_none")]
1023    pub page_size: Option<u32>,
1024    /// Contract field pageToken.
1025    #[serde(rename = "pageToken")]
1026    #[serde(default, skip_serializing_if = "Option::is_none")]
1027    pub page_token: Option<String>,
1028}
1029impl<'de> DeserializeStrict<'de> for ListOrganizationsRequest {
1030    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1031        #[derive(Deserialize)]
1032        #[serde(deny_unknown_fields)]
1033        struct __Wire {
1034            #[serde(rename = "active")]
1035            #[serde(default)]
1036            active: Strict<Option<bool>>,
1037            #[serde(rename = "pageSize")]
1038            #[serde(default)]
1039            page_size: Strict<Option<u32>>,
1040            #[serde(rename = "pageToken")]
1041            #[serde(default)]
1042            page_token: Strict<Option<String>>,
1043        }
1044        let wire = __Wire::deserialize(deserializer)?;
1045        Ok(Self {
1046            active: wire.active.0,
1047            page_size: wire.page_size.0,
1048            page_token: wire.page_token.0,
1049        })
1050    }
1051}
1052
1053/// An Organization member and provider profile.
1054#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1055pub struct Member {
1056    /// Contract field authMethod.
1057    #[serde(rename = "authMethod")]
1058    pub auth_method: AuthenticationMethod,
1059    /// Contract field createdAt.
1060    #[serde(rename = "createdAt")]
1061    #[serde(default, skip_serializing_if = "Option::is_none")]
1062    pub created_at: Option<String>,
1063    /// Contract field email.
1064    #[serde(rename = "email")]
1065    pub email: String,
1066    /// Contract field emailVerified.
1067    #[serde(rename = "emailVerified")]
1068    pub email_verified: bool,
1069    /// Contract field firstName.
1070    #[serde(rename = "firstName")]
1071    pub first_name: String,
1072    /// Contract field lastName.
1073    #[serde(rename = "lastName")]
1074    pub last_name: String,
1075    /// Contract field lastSignInAt.
1076    #[serde(rename = "lastSignInAt")]
1077    #[serde(default, skip_serializing_if = "Option::is_none")]
1078    pub last_sign_in_at: Option<String>,
1079    /// Contract field profilePictureUrl.
1080    #[serde(rename = "profilePictureUrl")]
1081    #[serde(default, skip_serializing_if = "Option::is_none")]
1082    pub profile_picture_url: Option<String>,
1083    /// Contract field role.
1084    #[serde(rename = "role")]
1085    #[serde(default, skip_serializing_if = "Option::is_none")]
1086    pub role: Option<OrganizationRole>,
1087    /// Contract field userId.
1088    #[serde(rename = "userId")]
1089    pub user_id: String,
1090}
1091impl<'de> DeserializeStrict<'de> for Member {
1092    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1093        #[derive(Deserialize)]
1094        #[serde(deny_unknown_fields)]
1095        struct __Wire {
1096            #[serde(rename = "authMethod")]
1097            auth_method: Strict<AuthenticationMethod>,
1098            #[serde(rename = "createdAt")]
1099            #[serde(default)]
1100            created_at: Strict<Option<String>>,
1101            #[serde(rename = "email")]
1102            email: Strict<String>,
1103            #[serde(rename = "emailVerified")]
1104            email_verified: Strict<bool>,
1105            #[serde(rename = "firstName")]
1106            first_name: Strict<String>,
1107            #[serde(rename = "lastName")]
1108            last_name: Strict<String>,
1109            #[serde(rename = "lastSignInAt")]
1110            #[serde(default)]
1111            last_sign_in_at: Strict<Option<String>>,
1112            #[serde(rename = "profilePictureUrl")]
1113            #[serde(default)]
1114            profile_picture_url: Strict<Option<String>>,
1115            #[serde(rename = "role")]
1116            #[serde(default)]
1117            role: Strict<Option<OrganizationRole>>,
1118            #[serde(rename = "userId")]
1119            user_id: Strict<String>,
1120        }
1121        let wire = __Wire::deserialize(deserializer)?;
1122        Ok(Self {
1123            auth_method: wire.auth_method.0,
1124            created_at: wire.created_at.0,
1125            email: wire.email.0,
1126            email_verified: wire.email_verified.0,
1127            first_name: wire.first_name.0,
1128            last_name: wire.last_name.0,
1129            last_sign_in_at: wire.last_sign_in_at.0,
1130            profile_picture_url: wire.profile_picture_url.0,
1131            role: wire.role.0,
1132            user_id: wire.user_id.0,
1133        })
1134    }
1135}
1136
1137/// One live provider page of Organization members.
1138#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1139pub struct MemberPage {
1140    /// Contract field items.
1141    #[serde(rename = "items")]
1142    pub items: Vec<Member>,
1143    /// Contract field nextPageToken.
1144    #[serde(rename = "nextPageToken")]
1145    #[serde(default, skip_serializing_if = "Option::is_none")]
1146    pub next_page_token: Option<String>,
1147}
1148impl<'de> DeserializeStrict<'de> for MemberPage {
1149    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1150        #[derive(Deserialize)]
1151        #[serde(deny_unknown_fields)]
1152        struct __Wire {
1153            #[serde(rename = "items")]
1154            items: Strict<Vec<Member>>,
1155            #[serde(rename = "nextPageToken")]
1156            #[serde(default)]
1157            next_page_token: Strict<Option<String>>,
1158        }
1159        let wire = __Wire::deserialize(deserializer)?;
1160        Ok(Self {
1161            items: wire.items.0,
1162            next_page_token: wire.next_page_token.0,
1163        })
1164    }
1165}
1166
1167/// One user membership in an Organization.
1168#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1169pub struct Membership {
1170    /// Contract field organization.
1171    #[serde(rename = "organization")]
1172    pub organization: Organization,
1173    /// Contract field role.
1174    #[serde(rename = "role")]
1175    pub role: OrganizationRole,
1176    /// Contract field userId.
1177    #[serde(rename = "userId")]
1178    pub user_id: String,
1179}
1180impl<'de> DeserializeStrict<'de> for Membership {
1181    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1182        #[derive(Deserialize)]
1183        #[serde(deny_unknown_fields)]
1184        struct __Wire {
1185            #[serde(rename = "organization")]
1186            organization: Strict<Organization>,
1187            #[serde(rename = "role")]
1188            role: Strict<OrganizationRole>,
1189            #[serde(rename = "userId")]
1190            user_id: Strict<String>,
1191        }
1192        let wire = __Wire::deserialize(deserializer)?;
1193        Ok(Self {
1194            organization: wire.organization.0,
1195            role: wire.role.0,
1196            user_id: wire.user_id.0,
1197        })
1198    }
1199}
1200
1201/// Live memberships ordered by Organization ID for the caller, or by provider membership ID for
1202/// synchronization.
1203#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1204pub struct MembershipPage {
1205    /// Contract field items.
1206    #[serde(rename = "items")]
1207    pub items: Vec<Membership>,
1208    /// Contract field nextPageToken.
1209    #[serde(rename = "nextPageToken")]
1210    #[serde(default, skip_serializing_if = "Option::is_none")]
1211    pub next_page_token: Option<String>,
1212}
1213impl<'de> DeserializeStrict<'de> for MembershipPage {
1214    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1215        #[derive(Deserialize)]
1216        #[serde(deny_unknown_fields)]
1217        struct __Wire {
1218            #[serde(rename = "items")]
1219            items: Strict<Vec<Membership>>,
1220            #[serde(rename = "nextPageToken")]
1221            #[serde(default)]
1222            next_page_token: Strict<Option<String>>,
1223        }
1224        let wire = __Wire::deserialize(deserializer)?;
1225        Ok(Self {
1226            items: wire.items.0,
1227            next_page_token: wire.next_page_token.0,
1228        })
1229    }
1230}
1231
1232/// An Organization identity and optional display name.
1233#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1234pub struct Organization {
1235    /// Contract field id.
1236    #[serde(rename = "id")]
1237    pub id: String,
1238    /// Contract field name.
1239    #[serde(rename = "name")]
1240    #[serde(default, skip_serializing_if = "Option::is_none")]
1241    pub name: Option<String>,
1242}
1243impl<'de> DeserializeStrict<'de> for Organization {
1244    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1245        #[derive(Deserialize)]
1246        #[serde(deny_unknown_fields)]
1247        struct __Wire {
1248            #[serde(rename = "id")]
1249            id: Strict<String>,
1250            #[serde(rename = "name")]
1251            #[serde(default)]
1252            name: Strict<Option<String>>,
1253        }
1254        let wire = __Wire::deserialize(deserializer)?;
1255        Ok(Self {
1256            id: wire.id.0,
1257            name: wire.name.0,
1258        })
1259    }
1260}
1261
1262/// Organization storage policy. Only Organization owners may read or write the full configuration.
1263#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1264pub struct OrganizationConfig {
1265    /// Contract field defaultFilesystem.
1266    #[serde(rename = "defaultFilesystem")]
1267    pub default_filesystem: DefaultFilesystem,
1268}
1269impl<'de> DeserializeStrict<'de> for OrganizationConfig {
1270    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1271        #[derive(Deserialize)]
1272        #[serde(deny_unknown_fields)]
1273        struct __Wire {
1274            #[serde(rename = "defaultFilesystem")]
1275            default_filesystem: Strict<DefaultFilesystem>,
1276        }
1277        let wire = __Wire::deserialize(deserializer)?;
1278        Ok(Self {
1279            default_filesystem: wire.default_filesystem.0,
1280        })
1281    }
1282}
1283
1284/// An administrative Organization record.
1285#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1286pub struct OrganizationDetails {
1287    /// Contract field deactivatedAt.
1288    #[serde(rename = "deactivatedAt")]
1289    #[serde(default, skip_serializing_if = "Option::is_none")]
1290    pub deactivated_at: Option<String>,
1291    /// Contract field id.
1292    #[serde(rename = "id")]
1293    pub id: String,
1294    /// Contract field name.
1295    #[serde(rename = "name")]
1296    #[serde(default, skip_serializing_if = "Option::is_none")]
1297    pub name: Option<String>,
1298}
1299impl<'de> DeserializeStrict<'de> for OrganizationDetails {
1300    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1301        #[derive(Deserialize)]
1302        #[serde(deny_unknown_fields)]
1303        struct __Wire {
1304            #[serde(rename = "deactivatedAt")]
1305            #[serde(default)]
1306            deactivated_at: Strict<Option<String>>,
1307            #[serde(rename = "id")]
1308            id: Strict<String>,
1309            #[serde(rename = "name")]
1310            #[serde(default)]
1311            name: Strict<Option<String>>,
1312        }
1313        let wire = __Wire::deserialize(deserializer)?;
1314        Ok(Self {
1315            deactivated_at: wire.deactivated_at.0,
1316            id: wire.id.0,
1317            name: wire.name.0,
1318        })
1319    }
1320}
1321
1322/// The Organization identities synchronized by one provider page, in descending provider ID order.
1323#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1324pub struct OrganizationIdPage {
1325    /// Contract field items.
1326    #[serde(rename = "items")]
1327    pub items: Vec<String>,
1328    /// Contract field nextPageToken.
1329    #[serde(rename = "nextPageToken")]
1330    #[serde(default, skip_serializing_if = "Option::is_none")]
1331    pub next_page_token: Option<String>,
1332}
1333impl<'de> DeserializeStrict<'de> for OrganizationIdPage {
1334    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1335        #[derive(Deserialize)]
1336        #[serde(deny_unknown_fields)]
1337        struct __Wire {
1338            #[serde(rename = "items")]
1339            items: Strict<Vec<String>>,
1340            #[serde(rename = "nextPageToken")]
1341            #[serde(default)]
1342            next_page_token: Strict<Option<String>>,
1343        }
1344        let wire = __Wire::deserialize(deserializer)?;
1345        Ok(Self {
1346            items: wire.items.0,
1347            next_page_token: wire.next_page_token.0,
1348        })
1349    }
1350}
1351
1352/// Live administrative Organization records ordered by ID.
1353#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1354pub struct OrganizationPage {
1355    /// Contract field items.
1356    #[serde(rename = "items")]
1357    pub items: Vec<OrganizationDetails>,
1358    /// Contract field nextPageToken.
1359    #[serde(rename = "nextPageToken")]
1360    #[serde(default, skip_serializing_if = "Option::is_none")]
1361    pub next_page_token: Option<String>,
1362}
1363impl<'de> DeserializeStrict<'de> for OrganizationPage {
1364    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1365        #[derive(Deserialize)]
1366        #[serde(deny_unknown_fields)]
1367        struct __Wire {
1368            #[serde(rename = "items")]
1369            items: Strict<Vec<OrganizationDetails>>,
1370            #[serde(rename = "nextPageToken")]
1371            #[serde(default)]
1372            next_page_token: Strict<Option<String>>,
1373        }
1374        let wire = __Wire::deserialize(deserializer)?;
1375        Ok(Self {
1376            items: wire.items.0,
1377            next_page_token: wire.next_page_token.0,
1378        })
1379    }
1380}
1381
1382/// Organization membership role.
1383#[derive(Clone, Debug, PartialEq, Eq)]
1384pub enum OrganizationRole {
1385    /// A known contract value.
1386    Owner,
1387    /// A known contract value.
1388    Member,
1389    /// A known contract value.
1390    Guest,
1391    /// A value introduced by a newer server.
1392    Unknown(String),
1393}
1394impl Serialize for OrganizationRole {
1395    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1396        serializer.serialize_str(match self {
1397            Self::Owner => "owner",
1398            Self::Member => "member",
1399            Self::Guest => "guest",
1400            Self::Unknown(value) => value,
1401        })
1402    }
1403}
1404impl<'de> Deserialize<'de> for OrganizationRole {
1405    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1406        Ok(match String::deserialize(deserializer)?.as_str() {
1407            "owner" => Self::Owner,
1408            "member" => Self::Member,
1409            "guest" => Self::Guest,
1410            value => Self::Unknown(value.to_owned()),
1411        })
1412    }
1413}
1414impl<'de> DeserializeStrict<'de> for OrganizationRole {
1415    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1416        #[derive(Deserialize)]
1417        enum __Known {
1418            #[serde(rename = "owner")]
1419            Owner,
1420            #[serde(rename = "member")]
1421            Member,
1422            #[serde(rename = "guest")]
1423            Guest,
1424        }
1425        Ok(match __Known::deserialize(deserializer)? {
1426            __Known::Owner => Self::Owner,
1427            __Known::Member => Self::Member,
1428            __Known::Guest => Self::Guest,
1429        })
1430    }
1431}
1432
1433/// The account setting to open in the administration portal.
1434#[derive(Clone, Debug, PartialEq, Eq)]
1435pub enum PortalIntent {
1436    /// A known contract value.
1437    Sso,
1438    /// A known contract value.
1439    DirectorySync,
1440    /// A known contract value.
1441    AuditLogs,
1442    /// A known contract value.
1443    LogStreams,
1444    /// A known contract value.
1445    DomainVerification,
1446    /// A known contract value.
1447    BringYourOwnKey,
1448    /// A value introduced by a newer server.
1449    Unknown(String),
1450}
1451impl Serialize for PortalIntent {
1452    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1453        serializer.serialize_str(match self {
1454            Self::Sso => "sso",
1455            Self::DirectorySync => "directory_sync",
1456            Self::AuditLogs => "audit_logs",
1457            Self::LogStreams => "log_streams",
1458            Self::DomainVerification => "domain_verification",
1459            Self::BringYourOwnKey => "bring_your_own_key",
1460            Self::Unknown(value) => value,
1461        })
1462    }
1463}
1464impl<'de> Deserialize<'de> for PortalIntent {
1465    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1466        Ok(match String::deserialize(deserializer)?.as_str() {
1467            "sso" => Self::Sso,
1468            "directory_sync" => Self::DirectorySync,
1469            "audit_logs" => Self::AuditLogs,
1470            "log_streams" => Self::LogStreams,
1471            "domain_verification" => Self::DomainVerification,
1472            "bring_your_own_key" => Self::BringYourOwnKey,
1473            value => Self::Unknown(value.to_owned()),
1474        })
1475    }
1476}
1477impl<'de> DeserializeStrict<'de> for PortalIntent {
1478    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1479        #[derive(Deserialize)]
1480        enum __Known {
1481            #[serde(rename = "sso")]
1482            Sso,
1483            #[serde(rename = "directory_sync")]
1484            DirectorySync,
1485            #[serde(rename = "audit_logs")]
1486            AuditLogs,
1487            #[serde(rename = "log_streams")]
1488            LogStreams,
1489            #[serde(rename = "domain_verification")]
1490            DomainVerification,
1491            #[serde(rename = "bring_your_own_key")]
1492            BringYourOwnKey,
1493        }
1494        Ok(match __Known::deserialize(deserializer)? {
1495            __Known::Sso => Self::Sso,
1496            __Known::DirectorySync => Self::DirectorySync,
1497            __Known::AuditLogs => Self::AuditLogs,
1498            __Known::LogStreams => Self::LogStreams,
1499            __Known::DomainVerification => Self::DomainVerification,
1500            __Known::BringYourOwnKey => Self::BringYourOwnKey,
1501        })
1502    }
1503}
1504
1505/// The administration portal URL.
1506#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1507pub struct PortalLink {
1508    /// Contract field url.
1509    #[serde(rename = "url")]
1510    pub url: String,
1511}
1512impl<'de> DeserializeStrict<'de> for PortalLink {
1513    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1514        #[derive(Deserialize)]
1515        #[serde(deny_unknown_fields)]
1516        struct __Wire {
1517            #[serde(rename = "url")]
1518            url: Strict<String>,
1519        }
1520        let wire = __Wire::deserialize(deserializer)?;
1521        Ok(Self { url: wire.url.0 })
1522    }
1523}
1524
1525/// Choose the administration portal setting.
1526#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1527pub struct PortalLinkRequest {
1528    /// Contract field intent.
1529    #[serde(rename = "intent")]
1530    pub intent: PortalIntent,
1531}
1532impl<'de> DeserializeStrict<'de> for PortalLinkRequest {
1533    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1534        #[derive(Deserialize)]
1535        #[serde(deny_unknown_fields)]
1536        struct __Wire {
1537            #[serde(rename = "intent")]
1538            intent: Strict<PortalIntent>,
1539        }
1540        let wire = __Wire::deserialize(deserializer)?;
1541        Ok(Self {
1542            intent: wire.intent.0,
1543        })
1544    }
1545}
1546
1547/// R2 storage with an access key.
1548#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1549pub struct R2Storage {
1550    /// Contract field accessKeyId.
1551    #[serde(rename = "accessKeyId")]
1552    pub access_key_id: String,
1553    /// Contract field bucket.
1554    #[serde(rename = "bucket")]
1555    pub bucket: String,
1556    /// Contract field directory.
1557    #[serde(rename = "directory")]
1558    pub directory: String,
1559    /// Contract field endpoint.
1560    #[serde(rename = "endpoint")]
1561    pub endpoint: String,
1562    /// Contract field secretAccessKey.
1563    #[serde(rename = "secretAccessKey")]
1564    pub secret_access_key: AccessKey,
1565}
1566impl<'de> DeserializeStrict<'de> for R2Storage {
1567    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1568        #[derive(Deserialize)]
1569        #[serde(deny_unknown_fields)]
1570        struct __Wire {
1571            #[serde(rename = "accessKeyId")]
1572            access_key_id: Strict<String>,
1573            #[serde(rename = "bucket")]
1574            bucket: Strict<String>,
1575            #[serde(rename = "directory")]
1576            directory: Strict<String>,
1577            #[serde(rename = "endpoint")]
1578            endpoint: Strict<String>,
1579            #[serde(rename = "secretAccessKey")]
1580            secret_access_key: Strict<AccessKey>,
1581        }
1582        let wire = __Wire::deserialize(deserializer)?;
1583        Ok(Self {
1584            access_key_id: wire.access_key_id.0,
1585            bucket: wire.bucket.0,
1586            directory: wire.directory.0,
1587            endpoint: wire.endpoint.0,
1588            secret_access_key: wire.secret_access_key.0,
1589        })
1590    }
1591}
1592
1593/// S3-compatible storage with an access key.
1594#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1595pub struct S3CompatibleStorage {
1596    /// Contract field accessKeyId.
1597    #[serde(rename = "accessKeyId")]
1598    pub access_key_id: String,
1599    /// Contract field bucket.
1600    #[serde(rename = "bucket")]
1601    pub bucket: String,
1602    /// Contract field directory.
1603    #[serde(rename = "directory")]
1604    pub directory: String,
1605    /// Contract field endpoint.
1606    #[serde(rename = "endpoint")]
1607    pub endpoint: String,
1608    /// Contract field region.
1609    #[serde(rename = "region")]
1610    pub region: String,
1611    /// Contract field secretAccessKey.
1612    #[serde(rename = "secretAccessKey")]
1613    pub secret_access_key: AccessKey,
1614}
1615impl<'de> DeserializeStrict<'de> for S3CompatibleStorage {
1616    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1617        #[derive(Deserialize)]
1618        #[serde(deny_unknown_fields)]
1619        struct __Wire {
1620            #[serde(rename = "accessKeyId")]
1621            access_key_id: Strict<String>,
1622            #[serde(rename = "bucket")]
1623            bucket: Strict<String>,
1624            #[serde(rename = "directory")]
1625            directory: Strict<String>,
1626            #[serde(rename = "endpoint")]
1627            endpoint: Strict<String>,
1628            #[serde(rename = "region")]
1629            region: Strict<String>,
1630            #[serde(rename = "secretAccessKey")]
1631            secret_access_key: Strict<AccessKey>,
1632        }
1633        let wire = __Wire::deserialize(deserializer)?;
1634        Ok(Self {
1635            access_key_id: wire.access_key_id.0,
1636            bucket: wire.bucket.0,
1637            directory: wire.directory.0,
1638            endpoint: wire.endpoint.0,
1639            region: wire.region.0,
1640            secret_access_key: wire.secret_access_key.0,
1641        })
1642    }
1643}
1644
1645/// S3 storage using an IAM role.
1646#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1647pub struct S3Storage {
1648    /// Contract field bucket.
1649    #[serde(rename = "bucket")]
1650    pub bucket: String,
1651    /// Contract field directory.
1652    #[serde(rename = "directory")]
1653    pub directory: String,
1654    /// Contract field endpoint.
1655    #[serde(rename = "endpoint")]
1656    #[serde(default, skip_serializing_if = "Option::is_none")]
1657    pub endpoint: Option<String>,
1658    /// Contract field region.
1659    #[serde(rename = "region")]
1660    pub region: String,
1661    /// Contract field roleArn.
1662    #[serde(rename = "roleArn")]
1663    pub role_arn: String,
1664}
1665impl<'de> DeserializeStrict<'de> for S3Storage {
1666    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1667        #[derive(Deserialize)]
1668        #[serde(deny_unknown_fields)]
1669        struct __Wire {
1670            #[serde(rename = "bucket")]
1671            bucket: Strict<String>,
1672            #[serde(rename = "directory")]
1673            directory: Strict<String>,
1674            #[serde(rename = "endpoint")]
1675            #[serde(default)]
1676            endpoint: Strict<Option<String>>,
1677            #[serde(rename = "region")]
1678            region: Strict<String>,
1679            #[serde(rename = "roleArn")]
1680            role_arn: Strict<String>,
1681        }
1682        let wire = __Wire::deserialize(deserializer)?;
1683        Ok(Self {
1684            bucket: wire.bucket.0,
1685            directory: wire.directory.0,
1686            endpoint: wire.endpoint.0,
1687            region: wire.region.0,
1688            role_arn: wire.role_arn.0,
1689        })
1690    }
1691}
1692
1693/// Plaintext credential supplied only in a request. Stored credentials become vault references.
1694#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
1695#[serde(transparent)]
1696pub struct SecretToken(pub String);
1697impl std::fmt::Debug for SecretToken {
1698    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1699        formatter.write_str("SecretToken(<redacted>)")
1700    }
1701}
1702impl<'de> DeserializeStrict<'de> for SecretToken {
1703    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1704        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
1705    }
1706}
1707
1708/// The role to assign. The last owner cannot be demoted.
1709#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1710pub struct SetMemberRoleRequest {
1711    /// Contract field role.
1712    #[serde(rename = "role")]
1713    pub role: OrganizationRole,
1714}
1715impl<'de> DeserializeStrict<'de> for SetMemberRoleRequest {
1716    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1717        #[derive(Deserialize)]
1718        #[serde(deny_unknown_fields)]
1719        struct __Wire {
1720            #[serde(rename = "role")]
1721            role: Strict<OrganizationRole>,
1722        }
1723        let wire = __Wire::deserialize(deserializer)?;
1724        Ok(Self { role: wire.role.0 })
1725    }
1726}
1727
1728/// Storage supplied by an upstream Project.
1729#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
1730pub struct UpstreamStorage {
1731    /// Contract field projectId.
1732    #[serde(rename = "projectId")]
1733    pub project_id: String,
1734}
1735impl<'de> DeserializeStrict<'de> for UpstreamStorage {
1736    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1737        #[derive(Deserialize)]
1738        #[serde(deny_unknown_fields)]
1739        struct __Wire {
1740            #[serde(rename = "projectId")]
1741            project_id: Strict<String>,
1742        }
1743        let wire = __Wire::deserialize(deserializer)?;
1744        Ok(Self {
1745            project_id: wire.project_id.0,
1746        })
1747    }
1748}
1749
1750/// Typed errors declared by this service contract.
1751#[derive(Clone, Debug, PartialEq, Eq)]
1752pub enum OrganizationError {
1753    /// Organization:Conflict.
1754    Conflict { reason: String },
1755    /// Organization:InvalidArgument.
1756    InvalidArgument { reason: String },
1757    /// Organization:LimitReached.
1758    LimitReached { reason: String },
1759    /// Organization:NotFound.
1760    NotFound { resource: String },
1761}
1762impl OrganizationError {
1763    /// HTTP status for this declared error.
1764    pub fn status(&self) -> u16 {
1765        match self {
1766            Self::Conflict { .. } => 409,
1767            Self::InvalidArgument { .. } => 400,
1768            Self::LimitReached { .. } => 412,
1769            Self::NotFound { .. } => 404,
1770        }
1771    }
1772    /// Serialize only contract-declared error parameters.
1773    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
1774        match self {
1775            Self::Conflict { reason } => {
1776                let mut envelope =
1777                    ErrorEnvelope::new("CONFLICT", "Organization:Conflict", instance);
1778                envelope
1779                    .parameters
1780                    .insert("reason".into(), reason.to_string());
1781                envelope
1782            }
1783            Self::InvalidArgument { reason } => {
1784                let mut envelope = ErrorEnvelope::new(
1785                    "INVALID_ARGUMENT",
1786                    "Organization:InvalidArgument",
1787                    instance,
1788                );
1789                envelope
1790                    .parameters
1791                    .insert("reason".into(), reason.to_string());
1792                envelope
1793            }
1794            Self::LimitReached { reason } => {
1795                let mut envelope = ErrorEnvelope::new(
1796                    "FAILED_PRECONDITION",
1797                    "Organization:LimitReached",
1798                    instance,
1799                );
1800                envelope
1801                    .parameters
1802                    .insert("reason".into(), reason.to_string());
1803                envelope
1804            }
1805            Self::NotFound { resource } => {
1806                let mut envelope =
1807                    ErrorEnvelope::new("NOT_FOUND", "Organization:NotFound", instance);
1808                envelope
1809                    .parameters
1810                    .insert("resource".into(), resource.to_string());
1811                envelope
1812            }
1813        }
1814    }
1815    /// Decode a declared error and its typed error parameters.
1816    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
1817        if envelope.error_instance_id.len() != 36
1818            || Uuid::parse_str(&envelope.error_instance_id).is_err()
1819        {
1820            return None;
1821        }
1822        match envelope.error_name.as_str() {
1823            "Organization:Conflict" => {
1824                if envelope.error_code != "CONFLICT" {
1825                    return None;
1826                }
1827                let reason = envelope.parameters.get("reason")?.clone();
1828                Some(Self::Conflict { reason })
1829            }
1830            "Organization:InvalidArgument" => {
1831                if envelope.error_code != "INVALID_ARGUMENT" {
1832                    return None;
1833                }
1834                let reason = envelope.parameters.get("reason")?.clone();
1835                Some(Self::InvalidArgument { reason })
1836            }
1837            "Organization:LimitReached" => {
1838                if envelope.error_code != "FAILED_PRECONDITION" {
1839                    return None;
1840                }
1841                let reason = envelope.parameters.get("reason")?.clone();
1842                Some(Self::LimitReached { reason })
1843            }
1844            "Organization:NotFound" => {
1845                if envelope.error_code != "NOT_FOUND" {
1846                    return None;
1847                }
1848                let resource = envelope.parameters.get("resource")?.clone();
1849                Some(Self::NotFound { resource })
1850            }
1851            _ => None,
1852        }
1853    }
1854}
1855impl Display for OrganizationError {
1856    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1857        match self {
1858            Self::Conflict { reason } => {
1859                write!(formatter, "Organization:Conflict (reason: {})", reason)
1860            }
1861            Self::InvalidArgument { reason } => write!(
1862                formatter,
1863                "Organization:InvalidArgument (reason: {})",
1864                reason
1865            ),
1866            Self::LimitReached { reason } => {
1867                write!(formatter, "Organization:LimitReached (reason: {})", reason)
1868            }
1869            Self::NotFound { resource } => {
1870                write!(formatter, "Organization:NotFound (resource: {})", resource)
1871            }
1872        }
1873    }
1874}
1875impl StdError for OrganizationError {}
1876impl ServiceError for OrganizationError {
1877    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
1878        Self::envelope(self, instance)
1879    }
1880    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
1881        Self::decode_envelope(envelope)
1882    }
1883}
1884#[automatically_derived]
1885impl Default for CreateOrganizationRequest {
1886    fn default() -> Self {
1887        Self { name: None }
1888    }
1889}
1890#[automatically_derived]
1891impl Default for ListMembersRequest {
1892    fn default() -> Self {
1893        Self {
1894            page_size: None,
1895            page_token: None,
1896        }
1897    }
1898}
1899#[automatically_derived]
1900impl Default for ListMembershipsRequest {
1901    fn default() -> Self {
1902        Self {
1903            page_size: None,
1904            page_token: None,
1905        }
1906    }
1907}
1908#[automatically_derived]
1909impl Default for ListOrganizationsRequest {
1910    fn default() -> Self {
1911        Self {
1912            active: None,
1913            page_size: None,
1914            page_token: None,
1915        }
1916    }
1917}
spiral/api/organization/objects.rs

spiral/api/organization/
objects.rs
