spiral/api/authorization/
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::strict::{DeserializeStrict, Strict};
12use uuid::Uuid;
13
14/// A role granted to a principal in one Project.
15#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
16pub struct Grant {
17    /// Contract field conditions.
18    #[serde(rename = "conditions")]
19    pub conditions: BTreeMap<String, String>,
20    /// Contract field id.
21    #[serde(rename = "id")]
22    pub id: String,
23    /// Contract field principal.
24    #[serde(rename = "principal")]
25    pub principal: String,
26    /// Contract field projectId.
27    #[serde(rename = "projectId")]
28    pub project_id: String,
29    /// Contract field role.
30    #[serde(rename = "role")]
31    pub role: Role,
32}
33impl<'de> DeserializeStrict<'de> for Grant {
34    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
35        #[derive(Deserialize)]
36        #[serde(deny_unknown_fields)]
37        struct __Wire {
38            #[serde(rename = "conditions")]
39            conditions: Strict<BTreeMap<String, String>>,
40            #[serde(rename = "id")]
41            id: Strict<String>,
42            #[serde(rename = "principal")]
43            principal: Strict<String>,
44            #[serde(rename = "projectId")]
45            project_id: Strict<String>,
46            #[serde(rename = "role")]
47            role: Strict<Role>,
48        }
49        let wire = __Wire::deserialize(deserializer)?;
50        Ok(Self {
51            conditions: wire.conditions.0,
52            id: wire.id.0,
53            principal: wire.principal.0,
54            project_id: wire.project_id.0,
55            role: wire.role.0,
56        })
57    }
58}
59
60/// One live page of Grant records, ordered by ID. Continuations expire after one hour and bind the
61/// credential, operation, filters and page size.
62#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
63pub struct GrantPage {
64    /// Contract field items.
65    #[serde(rename = "items")]
66    pub items: Vec<Grant>,
67    /// Contract field nextPageToken.
68    #[serde(rename = "nextPageToken")]
69    #[serde(default, skip_serializing_if = "Option::is_none")]
70    pub next_page_token: Option<String>,
71}
72impl<'de> DeserializeStrict<'de> for GrantPage {
73    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
74        #[derive(Deserialize)]
75        #[serde(deny_unknown_fields)]
76        struct __Wire {
77            #[serde(rename = "items")]
78            items: Strict<Vec<Grant>>,
79            #[serde(rename = "nextPageToken")]
80            #[serde(default)]
81            next_page_token: Strict<Option<String>>,
82        }
83        let wire = __Wire::deserialize(deserializer)?;
84        Ok(Self {
85            items: wire.items.0,
86            next_page_token: wire.next_page_token.0,
87        })
88    }
89}
90
91/// The created Project role grant.
92#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
93pub struct GrantResponse {
94    /// Contract field grant.
95    #[serde(rename = "grant")]
96    pub grant: Grant,
97}
98impl<'de> DeserializeStrict<'de> for GrantResponse {
99    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
100        #[derive(Deserialize)]
101        #[serde(deny_unknown_fields)]
102        struct __Wire {
103            #[serde(rename = "grant")]
104            grant: Strict<Grant>,
105        }
106        let wire = __Wire::deserialize(deserializer)?;
107        Ok(Self {
108            grant: wire.grant.0,
109        })
110    }
111}
112
113/// A Project role and the principal receiving it.
114#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
115pub struct GrantRoleRequest {
116    /// Contract field principal.
117    #[serde(rename = "principal")]
118    pub principal: Principal,
119    /// Contract field role.
120    #[serde(rename = "role")]
121    pub role: Role,
122}
123impl<'de> DeserializeStrict<'de> for GrantRoleRequest {
124    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
125        #[derive(Deserialize)]
126        #[serde(deny_unknown_fields)]
127        struct __Wire {
128            #[serde(rename = "principal")]
129            principal: Strict<Principal>,
130            #[serde(rename = "role")]
131            role: Strict<Role>,
132        }
133        let wire = __Wire::deserialize(deserializer)?;
134        Ok(Self {
135            principal: wire.principal.0,
136            role: wire.role.0,
137        })
138    }
139}
140
141/// One batch of resource permission edges reviewed together.
142#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
143pub struct Installation {
144    /// Contract field createdAt.
145    #[serde(rename = "createdAt")]
146    pub created_at: String,
147    /// Contract field createdBy.
148    #[serde(rename = "createdBy")]
149    pub created_by: String,
150    /// Contract field id.
151    #[serde(rename = "id")]
152    pub id: String,
153    /// Contract field resourceMounts.
154    #[serde(rename = "resourceMounts")]
155    pub resource_mounts: Vec<ResourceMount>,
156    /// Contract field source.
157    #[serde(rename = "source")]
158    pub source: String,
159}
160impl<'de> DeserializeStrict<'de> for Installation {
161    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
162        #[derive(Deserialize)]
163        #[serde(deny_unknown_fields)]
164        struct __Wire {
165            #[serde(rename = "createdAt")]
166            created_at: Strict<String>,
167            #[serde(rename = "createdBy")]
168            created_by: Strict<String>,
169            #[serde(rename = "id")]
170            id: Strict<String>,
171            #[serde(rename = "resourceMounts")]
172            resource_mounts: Strict<Vec<ResourceMount>>,
173            #[serde(rename = "source")]
174            source: Strict<String>,
175        }
176        let wire = __Wire::deserialize(deserializer)?;
177        Ok(Self {
178            created_at: wire.created_at.0,
179            created_by: wire.created_by.0,
180            id: wire.id.0,
181            resource_mounts: wire.resource_mounts.0,
182            source: wire.source.0,
183        })
184    }
185}
186
187/// The installation and its resource permission edges.
188#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
189pub struct InstallationResponse {
190    /// Contract field installation.
191    #[serde(rename = "installation")]
192    pub installation: Installation,
193}
194impl<'de> DeserializeStrict<'de> for InstallationResponse {
195    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
196        #[derive(Deserialize)]
197        #[serde(deny_unknown_fields)]
198        struct __Wire {
199            #[serde(rename = "installation")]
200            installation: Strict<Installation>,
201        }
202        let wire = __Wire::deserialize(deserializer)?;
203        Ok(Self {
204            installation: wire.installation.0,
205        })
206    }
207}
208
209/// Continuation and optional exact principal-address filter. Page size defaults to 100 and must be
210/// 1..=1000. Continuations expire after one hour and bind the credential, filters and page size.
211#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
212pub struct ListGrantsRequest {
213    /// Contract field pageSize.
214    #[serde(rename = "pageSize")]
215    #[serde(default, skip_serializing_if = "Option::is_none")]
216    pub page_size: Option<u32>,
217    /// Contract field pageToken.
218    #[serde(rename = "pageToken")]
219    #[serde(default, skip_serializing_if = "Option::is_none")]
220    pub page_token: Option<String>,
221    /// Contract field principal.
222    #[serde(rename = "principal")]
223    #[serde(default, skip_serializing_if = "Option::is_none")]
224    pub principal: Option<String>,
225}
226impl<'de> DeserializeStrict<'de> for ListGrantsRequest {
227    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
228        #[derive(Deserialize)]
229        #[serde(deny_unknown_fields)]
230        struct __Wire {
231            #[serde(rename = "pageSize")]
232            #[serde(default)]
233            page_size: Strict<Option<u32>>,
234            #[serde(rename = "pageToken")]
235            #[serde(default)]
236            page_token: Strict<Option<String>>,
237            #[serde(rename = "principal")]
238            #[serde(default)]
239            principal: Strict<Option<String>>,
240        }
241        let wire = __Wire::deserialize(deserializer)?;
242        Ok(Self {
243            page_size: wire.page_size.0,
244            page_token: wire.page_token.0,
245            principal: wire.principal.0,
246        })
247    }
248}
249
250/// Whether to approve or reject a requested resource permission edge.
251#[derive(Clone, Debug, PartialEq, Eq)]
252pub enum MountDecision {
253    /// A known contract value.
254    Approve,
255    /// A known contract value.
256    Reject,
257    /// A value introduced by a newer server.
258    Unknown(String),
259}
260impl Serialize for MountDecision {
261    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
262        serializer.serialize_str(match self {
263            Self::Approve => "approve",
264            Self::Reject => "reject",
265            Self::Unknown(value) => value,
266        })
267    }
268}
269impl<'de> Deserialize<'de> for MountDecision {
270    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
271        Ok(match String::deserialize(deserializer)?.as_str() {
272            "approve" => Self::Approve,
273            "reject" => Self::Reject,
274            value => Self::Unknown(value.to_owned()),
275        })
276    }
277}
278impl<'de> DeserializeStrict<'de> for MountDecision {
279    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
280        #[derive(Deserialize)]
281        enum __Known {
282            #[serde(rename = "approve")]
283            Approve,
284            #[serde(rename = "reject")]
285            Reject,
286        }
287        Ok(match __Known::deserialize(deserializer)? {
288            __Known::Approve => Self::Approve,
289            __Known::Reject => Self::Reject,
290        })
291    }
292}
293
294/// Lifecycle status of a resource permission edge.
295#[derive(Clone, Debug, PartialEq, Eq)]
296pub enum MountStatus {
297    /// A known contract value.
298    Requested,
299    /// A known contract value.
300    Approved,
301    /// A known contract value.
302    Rejected,
303    /// A known contract value.
304    Revoked,
305    /// A known contract value.
306    Detached,
307    /// A value introduced by a newer server.
308    Unknown(String),
309}
310impl Serialize for MountStatus {
311    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
312        serializer.serialize_str(match self {
313            Self::Requested => "requested",
314            Self::Approved => "approved",
315            Self::Rejected => "rejected",
316            Self::Revoked => "revoked",
317            Self::Detached => "detached",
318            Self::Unknown(value) => value,
319        })
320    }
321}
322impl<'de> Deserialize<'de> for MountStatus {
323    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
324        Ok(match String::deserialize(deserializer)?.as_str() {
325            "requested" => Self::Requested,
326            "approved" => Self::Approved,
327            "rejected" => Self::Rejected,
328            "revoked" => Self::Revoked,
329            "detached" => Self::Detached,
330            value => Self::Unknown(value.to_owned()),
331        })
332    }
333}
334impl<'de> DeserializeStrict<'de> for MountStatus {
335    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
336        #[derive(Deserialize)]
337        enum __Known {
338            #[serde(rename = "requested")]
339            Requested,
340            #[serde(rename = "approved")]
341            Approved,
342            #[serde(rename = "rejected")]
343            Rejected,
344            #[serde(rename = "revoked")]
345            Revoked,
346            #[serde(rename = "detached")]
347            Detached,
348        }
349        Ok(match __Known::deserialize(deserializer)? {
350            __Known::Requested => Self::Requested,
351            __Known::Approved => Self::Approved,
352            __Known::Rejected => Self::Rejected,
353            __Known::Revoked => Self::Revoked,
354            __Known::Detached => Self::Detached,
355        })
356    }
357}
358
359/// Match an Organization membership role.
360#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
361pub struct OrganizationRolePrincipal {
362    /// Contract field organizationId.
363    #[serde(rename = "organizationId")]
364    pub organization_id: String,
365    /// Contract field role.
366    #[serde(rename = "role")]
367    pub role: String,
368}
369impl<'de> DeserializeStrict<'de> for OrganizationRolePrincipal {
370    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
371        #[derive(Deserialize)]
372        #[serde(deny_unknown_fields)]
373        struct __Wire {
374            #[serde(rename = "organizationId")]
375            organization_id: Strict<String>,
376            #[serde(rename = "role")]
377            role: Strict<String>,
378        }
379        let wire = __Wire::deserialize(deserializer)?;
380        Ok(Self {
381            organization_id: wire.organization_id.0,
382            role: wire.role.0,
383        })
384    }
385}
386
387/// Match a user acting in an Organization.
388#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
389pub struct OrganizationUserPrincipal {
390    /// Contract field organizationId.
391    #[serde(rename = "organizationId")]
392    pub organization_id: String,
393    /// Contract field userId.
394    #[serde(rename = "userId")]
395    pub user_id: String,
396}
397impl<'de> DeserializeStrict<'de> for OrganizationUserPrincipal {
398    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
399        #[derive(Deserialize)]
400        #[serde(deny_unknown_fields)]
401        struct __Wire {
402            #[serde(rename = "organizationId")]
403            organization_id: Strict<String>,
404            #[serde(rename = "userId")]
405            user_id: Strict<String>,
406        }
407        let wire = __Wire::deserialize(deserializer)?;
408        Ok(Self {
409            organization_id: wire.organization_id.0,
410            user_id: wire.user_id.0,
411        })
412    }
413}
414
415/// The identity or membership role that receives a Project role.
416#[derive(Clone, Debug, PartialEq, Eq)]
417pub enum Principal {
418    /// A known union arm.
419    OrganizationRole(OrganizationRolePrincipal),
420    /// A known union arm.
421    OrganizationUser(OrganizationUserPrincipal),
422    /// A known union arm.
423    Workload(WorkloadPrincipal),
424    /// An unknown discriminator and its complete wire object.
425    Unknown { tag: String, value: Value },
426}
427impl Serialize for Principal {
428    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
429        match self {
430            Self::OrganizationRole(value) => {
431                let mut object = serde_json::Map::new();
432                object.insert("type".into(), Value::String("organizationRole".into()));
433                object.insert(
434                    "organizationRole".into(),
435                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
436                );
437                Value::Object(object).serialize(serializer)
438            }
439            Self::OrganizationUser(value) => {
440                let mut object = serde_json::Map::new();
441                object.insert("type".into(), Value::String("organizationUser".into()));
442                object.insert(
443                    "organizationUser".into(),
444                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
445                );
446                Value::Object(object).serialize(serializer)
447            }
448            Self::Workload(value) => {
449                let mut object = serde_json::Map::new();
450                object.insert("type".into(), Value::String("workload".into()));
451                object.insert(
452                    "workload".into(),
453                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
454                );
455                Value::Object(object).serialize(serializer)
456            }
457            Self::Unknown { tag, value } => {
458                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
459                    return Err(serde::ser::Error::custom(
460                        "unknown union discriminator mismatch",
461                    ));
462                }
463                value.serialize(serializer)
464            }
465        }
466    }
467}
468impl<'de> Deserialize<'de> for Principal {
469    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
470        let value = Value::deserialize(deserializer)?;
471        let tag = value
472            .get("type")
473            .and_then(Value::as_str)
474            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
475        match tag {
476            "organizationRole" => Ok(Self::OrganizationRole(
477                serde_json::from_value(
478                    value
479                        .get("organizationRole")
480                        .cloned()
481                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
482                )
483                .map_err(serde::de::Error::custom)?,
484            )),
485            "organizationUser" => Ok(Self::OrganizationUser(
486                serde_json::from_value(
487                    value
488                        .get("organizationUser")
489                        .cloned()
490                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
491                )
492                .map_err(serde::de::Error::custom)?,
493            )),
494            "workload" => Ok(Self::Workload(
495                serde_json::from_value(
496                    value
497                        .get("workload")
498                        .cloned()
499                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
500                )
501                .map_err(serde::de::Error::custom)?,
502            )),
503            tag => Ok(Self::Unknown {
504                tag: tag.to_owned(),
505                value,
506            }),
507        }
508    }
509}
510impl<'de> DeserializeStrict<'de> for Principal {
511    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
512        #[derive(Deserialize)]
513        enum __Tag0 {
514            #[serde(rename = "organizationRole")]
515            Value,
516        }
517        #[derive(Deserialize)]
518        #[serde(deny_unknown_fields)]
519        struct __Arm0 {
520            #[serde(rename = "type")]
521            _tag: __Tag0,
522            #[serde(rename = "organizationRole")]
523            value: Strict<OrganizationRolePrincipal>,
524        }
525        #[derive(Deserialize)]
526        enum __Tag1 {
527            #[serde(rename = "organizationUser")]
528            Value,
529        }
530        #[derive(Deserialize)]
531        #[serde(deny_unknown_fields)]
532        struct __Arm1 {
533            #[serde(rename = "type")]
534            _tag: __Tag1,
535            #[serde(rename = "organizationUser")]
536            value: Strict<OrganizationUserPrincipal>,
537        }
538        #[derive(Deserialize)]
539        enum __Tag2 {
540            #[serde(rename = "workload")]
541            Value,
542        }
543        #[derive(Deserialize)]
544        #[serde(deny_unknown_fields)]
545        struct __Arm2 {
546            #[serde(rename = "type")]
547            _tag: __Tag2,
548            #[serde(rename = "workload")]
549            value: Strict<WorkloadPrincipal>,
550        }
551        #[derive(Deserialize)]
552        #[serde(untagged)]
553        enum __Known {
554            OrganizationRole(Box<__Arm0>),
555            OrganizationUser(Box<__Arm1>),
556            Workload(Box<__Arm2>),
557        }
558        Ok(match __Known::deserialize(deserializer)? {
559            __Known::OrganizationRole(arm) => Self::OrganizationRole(arm.value.0),
560            __Known::OrganizationUser(arm) => Self::OrganizationUser(arm.value.0),
561            __Known::Workload(arm) => Self::Workload(arm.value.0),
562        })
563    }
564}
565
566/// A permission edge between two resources, with its decision and audit metadata.
567#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
568pub struct ResourceMount {
569    /// Contract field createdAt.
570    #[serde(rename = "createdAt")]
571    pub created_at: String,
572    /// Contract field createdBy.
573    #[serde(rename = "createdBy")]
574    pub created_by: String,
575    /// Contract field id.
576    #[serde(rename = "id")]
577    pub id: String,
578    /// Contract field installationId.
579    #[serde(rename = "installationId")]
580    pub installation_id: String,
581    /// Contract field permission.
582    #[serde(rename = "permission")]
583    pub permission: String,
584    /// Contract field source.
585    #[serde(rename = "source")]
586    pub source: String,
587    /// Contract field status.
588    #[serde(rename = "status")]
589    pub status: MountStatus,
590    /// Contract field statusChangedAt.
591    #[serde(rename = "statusChangedAt")]
592    #[serde(default, skip_serializing_if = "Option::is_none")]
593    pub status_changed_at: Option<String>,
594    /// Contract field statusChangedBy.
595    #[serde(rename = "statusChangedBy")]
596    #[serde(default, skip_serializing_if = "Option::is_none")]
597    pub status_changed_by: Option<String>,
598    /// Contract field target.
599    #[serde(rename = "target")]
600    pub target: String,
601}
602impl<'de> DeserializeStrict<'de> for ResourceMount {
603    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
604        #[derive(Deserialize)]
605        #[serde(deny_unknown_fields)]
606        struct __Wire {
607            #[serde(rename = "createdAt")]
608            created_at: Strict<String>,
609            #[serde(rename = "createdBy")]
610            created_by: Strict<String>,
611            #[serde(rename = "id")]
612            id: Strict<String>,
613            #[serde(rename = "installationId")]
614            installation_id: Strict<String>,
615            #[serde(rename = "permission")]
616            permission: Strict<String>,
617            #[serde(rename = "source")]
618            source: Strict<String>,
619            #[serde(rename = "status")]
620            status: Strict<MountStatus>,
621            #[serde(rename = "statusChangedAt")]
622            #[serde(default)]
623            status_changed_at: Strict<Option<String>>,
624            #[serde(rename = "statusChangedBy")]
625            #[serde(default)]
626            status_changed_by: Strict<Option<String>>,
627            #[serde(rename = "target")]
628            target: Strict<String>,
629        }
630        let wire = __Wire::deserialize(deserializer)?;
631        Ok(Self {
632            created_at: wire.created_at.0,
633            created_by: wire.created_by.0,
634            id: wire.id.0,
635            installation_id: wire.installation_id.0,
636            permission: wire.permission.0,
637            source: wire.source.0,
638            status: wire.status.0,
639            status_changed_at: wire.status_changed_at.0,
640            status_changed_by: wire.status_changed_by.0,
641            target: wire.target.0,
642        })
643    }
644}
645
646/// Decisions keyed by resource mount ID. Omitted edges remain requested.
647#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
648pub struct ReviewRequest {
649    /// Contract field decisions.
650    #[serde(rename = "decisions")]
651    pub decisions: BTreeMap<String, MountDecision>,
652}
653impl<'de> DeserializeStrict<'de> for ReviewRequest {
654    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
655        #[derive(Deserialize)]
656        #[serde(deny_unknown_fields)]
657        struct __Wire {
658            #[serde(rename = "decisions")]
659            decisions: Strict<BTreeMap<String, MountDecision>>,
660        }
661        let wire = __Wire::deserialize(deserializer)?;
662        Ok(Self {
663            decisions: wire.decisions.0,
664        })
665    }
666}
667
668/// The resource permission edges transitioned by this decision.
669#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
670pub struct ReviewResponse {
671    /// Contract field resourceMounts.
672    #[serde(rename = "resourceMounts")]
673    pub resource_mounts: Vec<ResourceMount>,
674}
675impl<'de> DeserializeStrict<'de> for ReviewResponse {
676    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
677        #[derive(Deserialize)]
678        #[serde(deny_unknown_fields)]
679        struct __Wire {
680            #[serde(rename = "resourceMounts")]
681            resource_mounts: Strict<Vec<ResourceMount>>,
682        }
683        let wire = __Wire::deserialize(deserializer)?;
684        Ok(Self {
685            resource_mounts: wire.resource_mounts.0,
686        })
687    }
688}
689
690/// Project authorization role.
691#[derive(Clone, Debug, PartialEq, Eq)]
692pub enum Role {
693    /// A known contract value.
694    Admin,
695    /// A known contract value.
696    Editor,
697    /// A known contract value.
698    Viewer,
699    /// A value introduced by a newer server.
700    Unknown(String),
701}
702impl Serialize for Role {
703    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
704        serializer.serialize_str(match self {
705            Self::Admin => "admin",
706            Self::Editor => "editor",
707            Self::Viewer => "viewer",
708            Self::Unknown(value) => value,
709        })
710    }
711}
712impl<'de> Deserialize<'de> for Role {
713    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
714        Ok(match String::deserialize(deserializer)?.as_str() {
715            "admin" => Self::Admin,
716            "editor" => Self::Editor,
717            "viewer" => Self::Viewer,
718            value => Self::Unknown(value.to_owned()),
719        })
720    }
721}
722impl<'de> DeserializeStrict<'de> for Role {
723    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
724        #[derive(Deserialize)]
725        enum __Known {
726            #[serde(rename = "admin")]
727            Admin,
728            #[serde(rename = "editor")]
729            Editor,
730            #[serde(rename = "viewer")]
731            Viewer,
732        }
733        Ok(match __Known::deserialize(deserializer)? {
734            __Known::Admin => Self::Admin,
735            __Known::Editor => Self::Editor,
736            __Known::Viewer => Self::Viewer,
737        })
738    }
739}
740
741/// Match a Workload identity.
742#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
743pub struct WorkloadPrincipal {
744    /// Contract field workloadId.
745    #[serde(rename = "workloadId")]
746    pub workload_id: String,
747}
748impl<'de> DeserializeStrict<'de> for WorkloadPrincipal {
749    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
750        #[derive(Deserialize)]
751        #[serde(deny_unknown_fields)]
752        struct __Wire {
753            #[serde(rename = "workloadId")]
754            workload_id: Strict<String>,
755        }
756        let wire = __Wire::deserialize(deserializer)?;
757        Ok(Self {
758            workload_id: wire.workload_id.0,
759        })
760    }
761}
762
763/// Typed errors declared by this service contract.
764#[derive(Clone, Debug, PartialEq, Eq)]
765pub enum AuthorizationError {
766    /// Authorization:Conflict.
767    Conflict { reason: String },
768    /// Authorization:InvalidArgument.
769    InvalidArgument { reason: String },
770    /// Authorization:LimitReached.
771    LimitReached { reason: String },
772    /// Authorization:NotFound.
773    NotFound { resource: String },
774}
775impl AuthorizationError {
776    /// HTTP status for this declared error.
777    pub fn status(&self) -> u16 {
778        match self {
779            Self::Conflict { .. } => 409,
780            Self::InvalidArgument { .. } => 400,
781            Self::LimitReached { .. } => 412,
782            Self::NotFound { .. } => 404,
783        }
784    }
785    /// Serialize only contract-declared error parameters.
786    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
787        match self {
788            Self::Conflict { reason } => {
789                let mut envelope =
790                    ErrorEnvelope::new("CONFLICT", "Authorization:Conflict", instance);
791                envelope
792                    .parameters
793                    .insert("reason".into(), reason.to_string());
794                envelope
795            }
796            Self::InvalidArgument { reason } => {
797                let mut envelope = ErrorEnvelope::new(
798                    "INVALID_ARGUMENT",
799                    "Authorization:InvalidArgument",
800                    instance,
801                );
802                envelope
803                    .parameters
804                    .insert("reason".into(), reason.to_string());
805                envelope
806            }
807            Self::LimitReached { reason } => {
808                let mut envelope = ErrorEnvelope::new(
809                    "FAILED_PRECONDITION",
810                    "Authorization:LimitReached",
811                    instance,
812                );
813                envelope
814                    .parameters
815                    .insert("reason".into(), reason.to_string());
816                envelope
817            }
818            Self::NotFound { resource } => {
819                let mut envelope =
820                    ErrorEnvelope::new("NOT_FOUND", "Authorization:NotFound", instance);
821                envelope
822                    .parameters
823                    .insert("resource".into(), resource.to_string());
824                envelope
825            }
826        }
827    }
828    /// Decode a declared error and its typed error parameters.
829    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
830        if envelope.error_instance_id.len() != 36
831            || Uuid::parse_str(&envelope.error_instance_id).is_err()
832        {
833            return None;
834        }
835        match envelope.error_name.as_str() {
836            "Authorization:Conflict" => {
837                if envelope.error_code != "CONFLICT" {
838                    return None;
839                }
840                let reason = envelope.parameters.get("reason")?.clone();
841                Some(Self::Conflict { reason })
842            }
843            "Authorization:InvalidArgument" => {
844                if envelope.error_code != "INVALID_ARGUMENT" {
845                    return None;
846                }
847                let reason = envelope.parameters.get("reason")?.clone();
848                Some(Self::InvalidArgument { reason })
849            }
850            "Authorization:LimitReached" => {
851                if envelope.error_code != "FAILED_PRECONDITION" {
852                    return None;
853                }
854                let reason = envelope.parameters.get("reason")?.clone();
855                Some(Self::LimitReached { reason })
856            }
857            "Authorization:NotFound" => {
858                if envelope.error_code != "NOT_FOUND" {
859                    return None;
860                }
861                let resource = envelope.parameters.get("resource")?.clone();
862                Some(Self::NotFound { resource })
863            }
864            _ => None,
865        }
866    }
867}
868impl Display for AuthorizationError {
869    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
870        match self {
871            Self::Conflict { reason } => {
872                write!(formatter, "Authorization:Conflict (reason: {})", reason)
873            }
874            Self::InvalidArgument { reason } => write!(
875                formatter,
876                "Authorization:InvalidArgument (reason: {})",
877                reason
878            ),
879            Self::LimitReached { reason } => {
880                write!(formatter, "Authorization:LimitReached (reason: {})", reason)
881            }
882            Self::NotFound { resource } => {
883                write!(formatter, "Authorization:NotFound (resource: {})", resource)
884            }
885        }
886    }
887}
888impl StdError for AuthorizationError {}
889impl ServiceError for AuthorizationError {
890    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
891        Self::envelope(self, instance)
892    }
893    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
894        Self::decode_envelope(envelope)
895    }
896}
897#[automatically_derived]
898impl Default for ListGrantsRequest {
899    fn default() -> Self {
900        Self {
901            page_size: None,
902            page_token: None,
903            principal: None,
904        }
905    }
906}
spiral/api/authorization/objects.rs

spiral/api/authorization/
objects.rs
