spiral-sdk 0.1.10

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated transport-independent contract objects."]

use std::collections::BTreeMap;
use std::error::Error as StdError;
use std::fmt::{self, Display, Formatter};

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
use spiral_contract::error::{ErrorEnvelope, ServiceError};
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

/// AppAccessDecision contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AppAccessDecision {
    /// A known contract value.
    Allow,
    /// A known contract value.
    Block,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for AppAccessDecision {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Allow => "allow",
            Self::Block => "block",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for AppAccessDecision {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "allow" => Self::Allow,
            "block" => Self::Block,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for AppAccessDecision {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "allow")]
            Allow,
            #[serde(rename = "block")]
            Block,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Allow => Self::Allow,
            __Known::Block => Self::Block,
        })
    }
}

/// The configuration and status of an Application. An Application belongs to one Project and cannot
/// move to another. You cannot use the ID of a deleted Application again.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Application {
    /// Contract field configuration.
    #[serde(rename = "configuration")]
    pub configuration: ApplicationConfiguration,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: ApplicationStatus,
}
impl<'de> DeserializeStrict<'de> for Application {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "configuration")]
            configuration: Strict<ApplicationConfiguration>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "status")]
            status: Strict<ApplicationStatus>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            configuration: wire.configuration.0,
            id: wire.id.0,
            organization_id: wire.organization_id.0,
            project_id: wire.project_id.0,
            status: wire.status.0,
        })
    }
}

/// Who can sign in to the Application. `internal` admits only users of the Organization that owns
/// the Application's Project. `public` also admits users of other Organizations after Spiral
/// reviews the Application, subject to the app access of each Organization.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ApplicationAudience {
    /// A known contract value.
    Internal,
    /// A known contract value.
    Public,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ApplicationAudience {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Internal => "internal",
            Self::Public => "public",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ApplicationAudience {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "internal" => Self::Internal,
            "public" => Self::Public,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ApplicationAudience {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "internal")]
            Internal,
            #[serde(rename = "public")]
            Public,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Internal => Self::Internal,
            __Known::Public => Self::Public,
        })
    }
}

/// The exact redirect URIs and the resource scopes that the Application can request. The
/// Application calls the API of the stack that owns its Project. Each user still approves the
/// scopes, and the user's current permissions still apply. setupUrl returns the browser after
/// installation setup. It uses HTTPS (or HTTP on loopback) and receives installation_id,
/// setup_action and optional state; the Application checks the actual grant through the API.
/// redirectOnUpdate also returns after changes to an existing installation; it defaults to false
/// and requires setupUrl. installOnSignIn defaults to false. When enabled, sign-in requires an
/// active installation and lets an Organization owner install during user consent.
/// allowedCorsOrigins lists the exact browser origins (scheme, host and port) whose scripts may
/// obtain tokens and call ScanDAL as the Application.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApplicationConfiguration {
    /// Contract field allowedCorsOrigins.
    #[serde(rename = "allowedCorsOrigins")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_cors_origins: Option<Vec<String>>,
    /// Contract field audience.
    #[serde(rename = "audience")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<ApplicationAudience>,
    /// Contract field backgroundIdentity.
    #[serde(rename = "backgroundIdentity")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub background_identity: Option<BackgroundIdentity>,
    /// Contract field enabled.
    #[serde(rename = "enabled")]
    pub enabled: bool,
    /// Contract field installOnSignIn.
    #[serde(rename = "installOnSignIn")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub install_on_sign_in: Option<bool>,
    /// Contract field jwks.
    #[serde(rename = "jwks")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub jwks: Option<Value>,
    /// Contract field jwtBearerIssuers.
    #[serde(rename = "jwtBearerIssuers")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub jwt_bearer_issuers: Option<Vec<BackgroundIdentity>>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field redirectOnUpdate.
    #[serde(rename = "redirectOnUpdate")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub redirect_on_update: Option<bool>,
    /// Contract field redirectUris.
    #[serde(rename = "redirectUris")]
    pub redirect_uris: Vec<String>,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
    /// Contract field setupUrl.
    #[serde(rename = "setupUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub setup_url: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ApplicationConfiguration {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "allowedCorsOrigins")]
            #[serde(default)]
            allowed_cors_origins: Strict<Option<Vec<String>>>,
            #[serde(rename = "audience")]
            #[serde(default)]
            audience: Strict<Option<ApplicationAudience>>,
            #[serde(rename = "backgroundIdentity")]
            #[serde(default)]
            background_identity: Strict<Option<BackgroundIdentity>>,
            #[serde(rename = "enabled")]
            enabled: Strict<bool>,
            #[serde(rename = "installOnSignIn")]
            #[serde(default)]
            install_on_sign_in: Strict<Option<bool>>,
            #[serde(rename = "jwks")]
            #[serde(default)]
            jwks: Strict<Option<Value>>,
            #[serde(rename = "jwtBearerIssuers")]
            #[serde(default)]
            jwt_bearer_issuers: Strict<Option<Vec<BackgroundIdentity>>>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "redirectOnUpdate")]
            #[serde(default)]
            redirect_on_update: Strict<Option<bool>>,
            #[serde(rename = "redirectUris")]
            redirect_uris: Strict<Vec<String>>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
            #[serde(rename = "setupUrl")]
            #[serde(default)]
            setup_url: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            allowed_cors_origins: wire.allowed_cors_origins.0,
            audience: wire.audience.0,
            background_identity: wire.background_identity.0,
            enabled: wire.enabled.0,
            install_on_sign_in: wire.install_on_sign_in.0,
            jwks: wire.jwks.0,
            jwt_bearer_issuers: wire.jwt_bearer_issuers.0,
            name: wire.name.0,
            redirect_on_update: wire.redirect_on_update.0,
            redirect_uris: wire.redirect_uris.0,
            scopes: wire.scopes.0,
            setup_url: wire.setup_url.0,
        })
    }
}

/// ApplicationPage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApplicationPage {
    /// Contract field applications.
    #[serde(rename = "applications")]
    pub applications: Vec<Application>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ApplicationPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "applications")]
            applications: Strict<Vec<Application>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            applications: wire.applications.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// ApplicationScope contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApplicationScope {
    /// Contract field description.
    #[serde(rename = "description")]
    pub description: String,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
}
impl<'de> DeserializeStrict<'de> for ApplicationScope {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "description")]
            description: Strict<String>,
            #[serde(rename = "name")]
            name: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            description: wire.description.0,
            name: wire.name.0,
        })
    }
}

/// ApplicationScopes contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ApplicationScopes {
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<ApplicationScope>,
}
impl<'de> DeserializeStrict<'de> for ApplicationScopes {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<ApplicationScope>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            scopes: wire.scopes.0,
        })
    }
}

/// ApplicationStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ApplicationStatus {
    /// A known contract value.
    Active,
    /// A known contract value.
    Suspended,
    /// A known contract value.
    Deleted,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ApplicationStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Active => "active",
            Self::Suspended => "suspended",
            Self::Deleted => "deleted",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ApplicationStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "active" => Self::Active,
            "suspended" => Self::Suspended,
            "deleted" => Self::Deleted,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ApplicationStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "active")]
            Active,
            #[serde(rename = "suspended")]
            Suspended,
            #[serde(rename = "deleted")]
            Deleted,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Active => Self::Active,
            __Known::Suspended => Self::Suspended,
            __Known::Deleted => Self::Deleted,
        })
    }
}

/// An OpenID Connect identity of the Application's backend, such as a cloud service account.
/// backgroundIdentity applies to installation tokens; jwtBearerIssuers applies to app tokens. A
/// token must come from issuer and carry every listed claim value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BackgroundIdentity {
    /// Contract field audience.
    #[serde(rename = "audience")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
    /// Contract field claims.
    #[serde(rename = "claims")]
    pub claims: BTreeMap<String, String>,
    /// Contract field issuer.
    #[serde(rename = "issuer")]
    pub issuer: String,
}
impl<'de> DeserializeStrict<'de> for BackgroundIdentity {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "audience")]
            #[serde(default)]
            audience: Strict<Option<String>>,
            #[serde(rename = "claims")]
            claims: Strict<BTreeMap<String, String>>,
            #[serde(rename = "issuer")]
            issuer: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            audience: wire.audience.0,
            claims: wire.claims.0,
            issuer: wire.issuer.0,
        })
    }
}

/// ClientAppAccess contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ClientAppAccess {
    /// Contract field clientId.
    #[serde(rename = "clientId")]
    pub client_id: String,
    /// Contract field decision.
    #[serde(rename = "decision")]
    pub decision: AppAccessDecision,
}
impl<'de> DeserializeStrict<'de> for ClientAppAccess {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "clientId")]
            client_id: Strict<String>,
            #[serde(rename = "decision")]
            decision: Strict<AppAccessDecision>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            client_id: wire.client_id.0,
            decision: wire.decision.0,
        })
    }
}

/// The verified OAuth client and callback shown by the consent application.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentClient {
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field loopbackOnly.
    #[serde(rename = "loopbackOnly")]
    pub loopback_only: bool,
    /// Contract field managed.
    #[serde(rename = "managed")]
    pub managed: bool,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field publisher.
    #[serde(rename = "publisher")]
    pub publisher: String,
    /// Contract field publisherName.
    #[serde(rename = "publisherName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub publisher_name: Option<String>,
    /// Contract field redirectHost.
    #[serde(rename = "redirectHost")]
    pub redirect_host: String,
}
impl<'de> DeserializeStrict<'de> for ConsentClient {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "loopbackOnly")]
            loopback_only: Strict<bool>,
            #[serde(rename = "managed")]
            managed: Strict<bool>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "publisher")]
            publisher: Strict<String>,
            #[serde(rename = "publisherName")]
            #[serde(default)]
            publisher_name: Strict<Option<String>>,
            #[serde(rename = "redirectHost")]
            redirect_host: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            id: wire.id.0,
            loopback_only: wire.loopback_only.0,
            managed: wire.managed.0,
            name: wire.name.0,
            publisher: wire.publisher.0,
            publisher_name: wire.publisher_name.0,
            redirect_host: wire.redirect_host.0,
        })
    }
}

/// Accept only the listed requested scopes, or reject the authorization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentDecision {
    /// Contract field approve.
    #[serde(rename = "approve")]
    pub approve: bool,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for ConsentDecision {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "approve")]
            approve: Strict<bool>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            approve: wire.approve.0,
            scopes: wire.scopes.0,
        })
    }
}

/// Return the initiating browser to this authorization-server URL to finish consent.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentRedirect {
    /// Contract field redirectTo.
    #[serde(rename = "redirectTo")]
    pub redirect_to: String,
}
impl<'de> DeserializeStrict<'de> for ConsentRedirect {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "redirectTo")]
            redirect_to: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            redirect_to: wire.redirect_to.0,
        })
    }
}

/// The requested delegation. A challenge contains no access or refresh token.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentRequest {
    /// Contract field client.
    #[serde(rename = "client")]
    pub client: ConsentClient,
    /// Contract field resource.
    #[serde(rename = "resource")]
    pub resource: String,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
    /// Contract field skip.
    #[serde(rename = "skip")]
    pub skip: bool,
    /// Contract field subject.
    #[serde(rename = "subject")]
    pub subject: ConsentSubject,
}
impl<'de> DeserializeStrict<'de> for ConsentRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "client")]
            client: Strict<ConsentClient>,
            #[serde(rename = "resource")]
            resource: Strict<String>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
            #[serde(rename = "skip")]
            skip: Strict<bool>,
            #[serde(rename = "subject")]
            subject: Strict<ConsentSubject>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            client: wire.client.0,
            resource: wire.resource.0,
            scopes: wire.scopes.0,
            skip: wire.skip.0,
            subject: wire.subject.0,
        })
    }
}

/// The authenticated user and Organization bound to this authorization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentSubject {
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field organizationName.
    #[serde(rename = "organizationName")]
    pub organization_name: String,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for ConsentSubject {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "organizationName")]
            organization_name: Strict<String>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            organization_id: wire.organization_id.0,
            organization_name: wire.organization_name.0,
            user_id: wire.user_id.0,
        })
    }
}

/// Application details for an Organization member to review before installation. Credentials,
/// sign-in callbacks and developer Project configuration are not included. The registered setup URL
/// identifies where the browser returns after setup.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallableApplication {
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field installOnSignIn.
    #[serde(rename = "installOnSignIn")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub install_on_sign_in: Option<bool>,
    /// Contract field installation.
    #[serde(rename = "installation")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub installation: Option<Installation>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field redirectOnUpdate.
    #[serde(rename = "redirectOnUpdate")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub redirect_on_update: Option<bool>,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
    /// Contract field setupUrl.
    #[serde(rename = "setupUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub setup_url: Option<String>,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: ApplicationStatus,
}
impl<'de> DeserializeStrict<'de> for InstallableApplication {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "installOnSignIn")]
            #[serde(default)]
            install_on_sign_in: Strict<Option<bool>>,
            #[serde(rename = "installation")]
            #[serde(default)]
            installation: Strict<Option<Installation>>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "redirectOnUpdate")]
            #[serde(default)]
            redirect_on_update: Strict<Option<bool>>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
            #[serde(rename = "setupUrl")]
            #[serde(default)]
            setup_url: Strict<Option<String>>,
            #[serde(rename = "status")]
            status: Strict<ApplicationStatus>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            id: wire.id.0,
            install_on_sign_in: wire.install_on_sign_in.0,
            installation: wire.installation.0,
            name: wire.name.0,
            organization_id: wire.organization_id.0,
            redirect_on_update: wire.redirect_on_update.0,
            scopes: wire.scopes.0,
            setup_url: wire.setup_url.0,
            status: wire.status.0,
        })
    }
}

/// An Application installed in one Organization, where it acts as its own identity. `requested` is
/// the latest request. `approved` is what an Organization owner approved, and it is the only grant
/// that Spiral enforces. A request for more access takes effect only when an owner approves it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Installation {
    /// Contract field applicationId.
    #[serde(rename = "applicationId")]
    pub application_id: String,
    /// Contract field approved.
    #[serde(rename = "approved")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approved: Option<InstallationGrant>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field requested.
    #[serde(rename = "requested")]
    pub requested: InstallationGrant,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: InstallationStatus,
}
impl<'de> DeserializeStrict<'de> for Installation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "applicationId")]
            application_id: Strict<String>,
            #[serde(rename = "approved")]
            #[serde(default)]
            approved: Strict<Option<InstallationGrant>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "requested")]
            requested: Strict<InstallationGrant>,
            #[serde(rename = "status")]
            status: Strict<InstallationStatus>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            application_id: wire.application_id.0,
            approved: wire.approved.0,
            id: wire.id.0,
            organization_id: wire.organization_id.0,
            requested: wire.requested.0,
            status: wire.status.0,
        })
    }
}

/// Installation metadata and its API audience. configurationUrl is absent until the deployment
/// supplies an installation management UI.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationDetails {
    /// Contract field apiUrl.
    #[serde(rename = "apiUrl")]
    pub api_url: String,
    /// Contract field configurationUrl.
    #[serde(rename = "configurationUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configuration_url: Option<String>,
    /// Contract field installation.
    #[serde(rename = "installation")]
    pub installation: Installation,
}
impl<'de> DeserializeStrict<'de> for InstallationDetails {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "apiUrl")]
            api_url: Strict<String>,
            #[serde(rename = "configurationUrl")]
            #[serde(default)]
            configuration_url: Strict<Option<String>>,
            #[serde(rename = "installation")]
            installation: Strict<Installation>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            api_url: wire.api_url.0,
            configuration_url: wire.configuration_url.0,
            installation: wire.installation.0,
        })
    }
}

/// InstallationGrant contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationGrant {
    /// Contract field projects.
    #[serde(rename = "projects")]
    pub projects: InstallationProjects,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for InstallationGrant {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "projects")]
            projects: Strict<InstallationProjects>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            projects: wire.projects.0,
            scopes: wire.scopes.0,
        })
    }
}

/// InstallationPage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationPage {
    /// Contract field installations.
    #[serde(rename = "installations")]
    pub installations: Vec<Installation>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for InstallationPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "installations")]
            installations: Strict<Vec<Installation>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            installations: wire.installations.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// InstallationProject contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationProject {
    /// Contract field description.
    #[serde(rename = "description")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
}
impl<'de> DeserializeStrict<'de> for InstallationProject {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "description")]
            #[serde(default)]
            description: Strict<Option<String>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            description: wire.description.0,
            id: wire.id.0,
            organization_id: wire.organization_id.0,
        })
    }
}

/// InstallationProjectPage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationProjectPage {
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
    /// Contract field projects.
    #[serde(rename = "projects")]
    pub projects: Vec<InstallationProject>,
}
impl<'de> DeserializeStrict<'de> for InstallationProjectPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
            #[serde(rename = "projects")]
            projects: Strict<Vec<InstallationProject>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            next_page_token: wire.next_page_token.0,
            projects: wire.projects.0,
        })
    }
}

/// Every Project in the Organization, including Projects created later, when `all` is true.
/// Otherwise, only the listed Projects.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationProjects {
    /// Contract field all.
    #[serde(rename = "all")]
    pub all: bool,
    /// Contract field projectIds.
    #[serde(rename = "projectIds")]
    pub project_ids: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for InstallationProjects {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "all")]
            all: Strict<bool>,
            #[serde(rename = "projectIds")]
            project_ids: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            all: wire.all.0,
            project_ids: wire.project_ids.0,
        })
    }
}

/// InstallationRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationRequest {
    /// Contract field applicationId.
    #[serde(rename = "applicationId")]
    pub application_id: String,
    /// Contract field projects.
    #[serde(rename = "projects")]
    pub projects: InstallationProjects,
    /// Contract field scopes.
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for InstallationRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "applicationId")]
            application_id: Strict<String>,
            #[serde(rename = "projects")]
            projects: Strict<InstallationProjects>,
            #[serde(rename = "scopes")]
            scopes: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            application_id: wire.application_id.0,
            projects: wire.projects.0,
            scopes: wire.scopes.0,
        })
    }
}

/// Approve or decline the exact request shown to an Organization owner. A changed request returns
/// Conflict and must be reviewed again. Declining an update preserves the existing approval;
/// declining a new installation removes the request.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationReview {
    /// Contract field approve.
    #[serde(rename = "approve")]
    pub approve: bool,
    /// Contract field requested.
    #[serde(rename = "requested")]
    pub requested: InstallationGrant,
}
impl<'de> DeserializeStrict<'de> for InstallationReview {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "approve")]
            approve: Strict<bool>,
            #[serde(rename = "requested")]
            requested: Strict<InstallationGrant>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            approve: wire.approve.0,
            requested: wire.requested.0,
        })
    }
}

/// InstallationStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum InstallationStatus {
    /// A known contract value.
    Requested,
    /// A known contract value.
    Active,
    /// A known contract value.
    Suspended,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for InstallationStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Requested => "requested",
            Self::Active => "active",
            Self::Suspended => "suspended",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for InstallationStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "requested" => Self::Requested,
            "active" => Self::Active,
            "suspended" => Self::Suspended,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for InstallationStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "requested")]
            Requested,
            #[serde(rename = "active")]
            Active,
            #[serde(rename = "suspended")]
            Suspended,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Requested => Self::Requested,
            __Known::Active => Self::Active,
            __Known::Suspended => Self::Suspended,
        })
    }
}

/// InstallationStatusChange contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationStatusChange {
    /// Contract field enabled.
    #[serde(rename = "enabled")]
    pub enabled: bool,
}
impl<'de> DeserializeStrict<'de> for InstallationStatusChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "enabled")]
            enabled: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            enabled: wire.enabled.0,
        })
    }
}

/// InstallationSummary contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstallationSummary {
    /// Contract field apiUrl.
    #[serde(rename = "apiUrl")]
    pub api_url: String,
    /// Contract field applicationId.
    #[serde(rename = "applicationId")]
    pub application_id: String,
    /// Contract field approvedScopes.
    #[serde(rename = "approvedScopes")]
    pub approved_scopes: Vec<String>,
    /// Contract field configurationUrl.
    #[serde(rename = "configurationUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configuration_url: Option<String>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field requestedScopes.
    #[serde(rename = "requestedScopes")]
    pub requested_scopes: Vec<String>,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: InstallationStatus,
}
impl<'de> DeserializeStrict<'de> for InstallationSummary {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "apiUrl")]
            api_url: Strict<String>,
            #[serde(rename = "applicationId")]
            application_id: Strict<String>,
            #[serde(rename = "approvedScopes")]
            approved_scopes: Strict<Vec<String>>,
            #[serde(rename = "configurationUrl")]
            #[serde(default)]
            configuration_url: Strict<Option<String>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "requestedScopes")]
            requested_scopes: Strict<Vec<String>>,
            #[serde(rename = "status")]
            status: Strict<InstallationStatus>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            api_url: wire.api_url.0,
            application_id: wire.application_id.0,
            approved_scopes: wire.approved_scopes.0,
            configuration_url: wire.configuration_url.0,
            id: wire.id.0,
            organization_id: wire.organization_id.0,
            requested_scopes: wire.requested_scopes.0,
            status: wire.status.0,
        })
    }
}

/// ListApplicationsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListApplicationsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ListApplicationsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// The Applications and MCP clients that the users of an Organization can sign in to. The decision
/// for a listed client applies first. `unlisted` applies to every other client.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationAppAccess {
    /// Contract field clients.
    #[serde(rename = "clients")]
    pub clients: Vec<ClientAppAccess>,
    /// Contract field unlisted.
    #[serde(rename = "unlisted")]
    pub unlisted: UnlistedAppAccess,
}
impl<'de> DeserializeStrict<'de> for OrganizationAppAccess {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "clients")]
            clients: Strict<Vec<ClientAppAccess>>,
            #[serde(rename = "unlisted")]
            unlisted: Strict<UnlistedAppAccess>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            clients: wire.clients.0,
            unlisted: wire.unlisted.0,
        })
    }
}

/// What happens to an Application that the Organization did not list. `allow_reviewed` allows
/// Applications that Spiral reviewed. `block` blocks all of them.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum UnlistedAppAccess {
    /// A known contract value.
    AllowReviewed,
    /// A known contract value.
    Block,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for UnlistedAppAccess {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::AllowReviewed => "allow_reviewed",
            Self::Block => "block",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for UnlistedAppAccess {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "allow_reviewed" => Self::AllowReviewed,
            "block" => Self::Block,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for UnlistedAppAccess {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "allow_reviewed")]
            AllowReviewed,
            #[serde(rename = "block")]
            Block,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AllowReviewed => Self::AllowReviewed,
            __Known::Block => Self::Block,
        })
    }
}

/// Setup state for the caller's app and Organization. An absent installation means setup has not
/// started. Project enumeration uses the user installation project list.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct UserInstallation {
    /// Contract field installation.
    #[serde(rename = "installation")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub installation: Option<InstallationSummary>,
}
impl<'de> DeserializeStrict<'de> for UserInstallation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "installation")]
            #[serde(default)]
            installation: Strict<Option<InstallationSummary>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            installation: wire.installation.0,
        })
    }
}

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AppsError {
    /// Apps:Conflict.
    Conflict { application_id: String },
    /// Apps:ConsentConflict.
    ConsentConflict { reason: String },
    /// Apps:InvalidArgument.
    InvalidArgument { reason: String },
    /// Apps:InvalidConsent.
    InvalidConsent { reason: String },
    /// Apps:NotFound.
    NotFound { application_id: String },
    /// Apps:RegistrationUnavailable.
    RegistrationUnavailable { application_id: String },
}
impl AppsError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::Conflict { .. } => 409,
            Self::ConsentConflict { .. } => 409,
            Self::InvalidArgument { .. } => 400,
            Self::InvalidConsent { .. } => 400,
            Self::NotFound { .. } => 404,
            Self::RegistrationUnavailable { .. } => 500,
        }
    }
    /// Serialize only contract-declared error parameters.
    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
        match self {
            Self::Conflict { application_id } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Apps:Conflict", instance);
                envelope
                    .parameters
                    .insert("applicationId".into(), application_id.to_string());
                envelope
            }
            Self::ConsentConflict { reason } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Apps:ConsentConflict", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidArgument { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Apps:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidConsent { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Apps:InvalidConsent", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NotFound { application_id } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Apps:NotFound", instance);
                envelope
                    .parameters
                    .insert("applicationId".into(), application_id.to_string());
                envelope
            }
            Self::RegistrationUnavailable { application_id } => {
                let mut envelope =
                    ErrorEnvelope::new("INTERNAL", "Apps:RegistrationUnavailable", instance);
                envelope
                    .parameters
                    .insert("applicationId".into(), application_id.to_string());
                envelope
            }
        }
    }
    /// Decode a declared error and its typed error parameters.
    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        if envelope.error_instance_id.len() != 36
            || Uuid::parse_str(&envelope.error_instance_id).is_err()
        {
            return None;
        }
        match envelope.error_name.as_str() {
            "Apps:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let application_id = envelope.parameters.get("applicationId")?.clone();
                Some(Self::Conflict { application_id })
            }
            "Apps:ConsentConflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::ConsentConflict { reason })
            }
            "Apps:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Apps:InvalidConsent" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidConsent { reason })
            }
            "Apps:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let application_id = envelope.parameters.get("applicationId")?.clone();
                Some(Self::NotFound { application_id })
            }
            "Apps:RegistrationUnavailable" => {
                if envelope.error_code != "INTERNAL" {
                    return None;
                }
                let application_id = envelope.parameters.get("applicationId")?.clone();
                Some(Self::RegistrationUnavailable { application_id })
            }
            _ => None,
        }
    }
}
impl Display for AppsError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Conflict { application_id } => write!(
                formatter,
                "Apps:Conflict (applicationId: {})",
                application_id
            ),
            Self::ConsentConflict { reason } => {
                write!(formatter, "Apps:ConsentConflict (reason: {})", reason)
            }
            Self::InvalidArgument { reason } => {
                write!(formatter, "Apps:InvalidArgument (reason: {})", reason)
            }
            Self::InvalidConsent { reason } => {
                write!(formatter, "Apps:InvalidConsent (reason: {})", reason)
            }
            Self::NotFound { application_id } => write!(
                formatter,
                "Apps:NotFound (applicationId: {})",
                application_id
            ),
            Self::RegistrationUnavailable { application_id } => write!(
                formatter,
                "Apps:RegistrationUnavailable (applicationId: {})",
                application_id
            ),
        }
    }
}
impl StdError for AppsError {}
impl ServiceError for AppsError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}
#[automatically_derived]
impl Default for ListApplicationsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}