polyester-sdk 0.1.0-alpha.33

// @generated by buffa-codegen. DO NOT EDIT.

/// FailureReason identifies why rate-limit evaluation rejected a request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum FailureReason {
    /// No rate-limit failure reason was provided.
    REASON_UNSPECIFIED = 0i32,
    /// The active weighted quota did not have enough capacity.
    QUOTA_EXCEEDED = 1i32,
    /// The required rate-limit authority could not make a safe decision.
    AUTHORITY_UNAVAILABLE = 2i32,
}
impl FailureReason {
    ///Idiomatic alias for [`Self::REASON_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ReasonUnspecified: Self = Self::REASON_UNSPECIFIED;
    ///Idiomatic alias for [`Self::QUOTA_EXCEEDED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const QuotaExceeded: Self = Self::QUOTA_EXCEEDED;
    ///Idiomatic alias for [`Self::AUTHORITY_UNAVAILABLE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const AuthorityUnavailable: Self = Self::AUTHORITY_UNAVAILABLE;
}
impl ::core::default::Default for FailureReason {
    fn default() -> Self {
        Self::REASON_UNSPECIFIED
    }
}
impl ::serde::Serialize for FailureReason {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        s.serialize_str(::buffa::Enumeration::proto_name(self))
    }
}
impl<'de> ::serde::Deserialize<'de> for FailureReason {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = FailureReason;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(FailureReason)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<FailureReason, E> {
                <FailureReason as ::buffa::Enumeration>::from_proto_name(v)
                    .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
            }
            fn visit_i64<E: ::serde::de::Error>(
                self,
                v: i64,
            ) -> ::core::result::Result<FailureReason, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <FailureReason as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<FailureReason, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <FailureReason as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<FailureReason, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for FailureReason {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
impl ::buffa::Enumeration for FailureReason {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::REASON_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::QUOTA_EXCEEDED),
            2i32 => ::core::option::Option::Some(Self::AUTHORITY_UNAVAILABLE),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::REASON_UNSPECIFIED => "REASON_UNSPECIFIED",
            Self::QUOTA_EXCEEDED => "QUOTA_EXCEEDED",
            Self::AUTHORITY_UNAVAILABLE => "AUTHORITY_UNAVAILABLE",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "REASON_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::REASON_UNSPECIFIED)
            }
            "QUOTA_EXCEEDED" => ::core::option::Option::Some(Self::QUOTA_EXCEEDED),
            "AUTHORITY_UNAVAILABLE" => {
                ::core::option::Option::Some(Self::AUTHORITY_UNAVAILABLE)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::REASON_UNSPECIFIED, Self::QUOTA_EXCEEDED, Self::AUTHORITY_UNAVAILABLE]
    }
}
/// PolicyClass identifies the mutable quota family used for a decision.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum PolicyClass {
    /// No policy class was provided.
    CLASS_UNSPECIFIED = 0i32,
    /// Public authentication operations.
    AUTH_PUBLIC = 1i32,
    /// Trading order and trigger placement operations.
    TRADING_PLACE = 2i32,
    /// Trading order and trigger cancellation operations.
    TRADING_CANCEL = 3i32,
    /// Authenticated trading read operations.
    TRADING_READ = 4i32,
    /// General account and subaccount administration operations.
    ACCOUNT_ADMIN = 5i32,
    /// Public market-data and realtime read operations.
    PUBLIC_READ = 6i32,
    /// MFA, recovery, API-key, policy, and security-control mutations.
    ACCOUNT_SECURITY = 7i32,
    /// Deposit-address creation that may call an upstream provider.
    DEPOSIT_CREATE = 8i32,
    /// Off-chain internal ledger transfer admission.
    INTERNAL_TRANSFER = 9i32,
    /// Chain or lifecycle withdraw submission.
    WITHDRAW_SUBMIT = 10i32,
    /// Withdraw destination validation.
    WITHDRAW_VALIDATE = 11i32,
    /// Guard-signer wallet and protected-action operations.
    GUARD_SIGN = 12i32,
    /// External social-provider work.
    SOCIAL_PROVIDER = 13i32,
}
impl PolicyClass {
    ///Idiomatic alias for [`Self::CLASS_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ClassUnspecified: Self = Self::CLASS_UNSPECIFIED;
    ///Idiomatic alias for [`Self::AUTH_PUBLIC`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const AuthPublic: Self = Self::AUTH_PUBLIC;
    ///Idiomatic alias for [`Self::TRADING_PLACE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TradingPlace: Self = Self::TRADING_PLACE;
    ///Idiomatic alias for [`Self::TRADING_CANCEL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TradingCancel: Self = Self::TRADING_CANCEL;
    ///Idiomatic alias for [`Self::TRADING_READ`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TradingRead: Self = Self::TRADING_READ;
    ///Idiomatic alias for [`Self::ACCOUNT_ADMIN`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const AccountAdmin: Self = Self::ACCOUNT_ADMIN;
    ///Idiomatic alias for [`Self::PUBLIC_READ`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PublicRead: Self = Self::PUBLIC_READ;
    ///Idiomatic alias for [`Self::ACCOUNT_SECURITY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const AccountSecurity: Self = Self::ACCOUNT_SECURITY;
    ///Idiomatic alias for [`Self::DEPOSIT_CREATE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const DepositCreate: Self = Self::DEPOSIT_CREATE;
    ///Idiomatic alias for [`Self::INTERNAL_TRANSFER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const InternalTransfer: Self = Self::INTERNAL_TRANSFER;
    ///Idiomatic alias for [`Self::WITHDRAW_SUBMIT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const WithdrawSubmit: Self = Self::WITHDRAW_SUBMIT;
    ///Idiomatic alias for [`Self::WITHDRAW_VALIDATE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const WithdrawValidate: Self = Self::WITHDRAW_VALIDATE;
    ///Idiomatic alias for [`Self::GUARD_SIGN`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const GuardSign: Self = Self::GUARD_SIGN;
    ///Idiomatic alias for [`Self::SOCIAL_PROVIDER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SocialProvider: Self = Self::SOCIAL_PROVIDER;
}
impl ::core::default::Default for PolicyClass {
    fn default() -> Self {
        Self::CLASS_UNSPECIFIED
    }
}
impl ::serde::Serialize for PolicyClass {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        s.serialize_str(::buffa::Enumeration::proto_name(self))
    }
}
impl<'de> ::serde::Deserialize<'de> for PolicyClass {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = PolicyClass;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(PolicyClass)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<PolicyClass, E> {
                <PolicyClass as ::buffa::Enumeration>::from_proto_name(v)
                    .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
            }
            fn visit_i64<E: ::serde::de::Error>(
                self,
                v: i64,
            ) -> ::core::result::Result<PolicyClass, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <PolicyClass as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<PolicyClass, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <PolicyClass as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<PolicyClass, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for PolicyClass {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
impl ::buffa::Enumeration for PolicyClass {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CLASS_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::AUTH_PUBLIC),
            2i32 => ::core::option::Option::Some(Self::TRADING_PLACE),
            3i32 => ::core::option::Option::Some(Self::TRADING_CANCEL),
            4i32 => ::core::option::Option::Some(Self::TRADING_READ),
            5i32 => ::core::option::Option::Some(Self::ACCOUNT_ADMIN),
            6i32 => ::core::option::Option::Some(Self::PUBLIC_READ),
            7i32 => ::core::option::Option::Some(Self::ACCOUNT_SECURITY),
            8i32 => ::core::option::Option::Some(Self::DEPOSIT_CREATE),
            9i32 => ::core::option::Option::Some(Self::INTERNAL_TRANSFER),
            10i32 => ::core::option::Option::Some(Self::WITHDRAW_SUBMIT),
            11i32 => ::core::option::Option::Some(Self::WITHDRAW_VALIDATE),
            12i32 => ::core::option::Option::Some(Self::GUARD_SIGN),
            13i32 => ::core::option::Option::Some(Self::SOCIAL_PROVIDER),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CLASS_UNSPECIFIED => "CLASS_UNSPECIFIED",
            Self::AUTH_PUBLIC => "AUTH_PUBLIC",
            Self::TRADING_PLACE => "TRADING_PLACE",
            Self::TRADING_CANCEL => "TRADING_CANCEL",
            Self::TRADING_READ => "TRADING_READ",
            Self::ACCOUNT_ADMIN => "ACCOUNT_ADMIN",
            Self::PUBLIC_READ => "PUBLIC_READ",
            Self::ACCOUNT_SECURITY => "ACCOUNT_SECURITY",
            Self::DEPOSIT_CREATE => "DEPOSIT_CREATE",
            Self::INTERNAL_TRANSFER => "INTERNAL_TRANSFER",
            Self::WITHDRAW_SUBMIT => "WITHDRAW_SUBMIT",
            Self::WITHDRAW_VALIDATE => "WITHDRAW_VALIDATE",
            Self::GUARD_SIGN => "GUARD_SIGN",
            Self::SOCIAL_PROVIDER => "SOCIAL_PROVIDER",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CLASS_UNSPECIFIED" => ::core::option::Option::Some(Self::CLASS_UNSPECIFIED),
            "AUTH_PUBLIC" => ::core::option::Option::Some(Self::AUTH_PUBLIC),
            "TRADING_PLACE" => ::core::option::Option::Some(Self::TRADING_PLACE),
            "TRADING_CANCEL" => ::core::option::Option::Some(Self::TRADING_CANCEL),
            "TRADING_READ" => ::core::option::Option::Some(Self::TRADING_READ),
            "ACCOUNT_ADMIN" => ::core::option::Option::Some(Self::ACCOUNT_ADMIN),
            "PUBLIC_READ" => ::core::option::Option::Some(Self::PUBLIC_READ),
            "ACCOUNT_SECURITY" => ::core::option::Option::Some(Self::ACCOUNT_SECURITY),
            "DEPOSIT_CREATE" => ::core::option::Option::Some(Self::DEPOSIT_CREATE),
            "INTERNAL_TRANSFER" => ::core::option::Option::Some(Self::INTERNAL_TRANSFER),
            "WITHDRAW_SUBMIT" => ::core::option::Option::Some(Self::WITHDRAW_SUBMIT),
            "WITHDRAW_VALIDATE" => ::core::option::Option::Some(Self::WITHDRAW_VALIDATE),
            "GUARD_SIGN" => ::core::option::Option::Some(Self::GUARD_SIGN),
            "SOCIAL_PROVIDER" => ::core::option::Option::Some(Self::SOCIAL_PROVIDER),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CLASS_UNSPECIFIED,
            Self::AUTH_PUBLIC,
            Self::TRADING_PLACE,
            Self::TRADING_CANCEL,
            Self::TRADING_READ,
            Self::ACCOUNT_ADMIN,
            Self::PUBLIC_READ,
            Self::ACCOUNT_SECURITY,
            Self::DEPOSIT_CREATE,
            Self::INTERNAL_TRANSFER,
            Self::WITHDRAW_SUBMIT,
            Self::WITHDRAW_VALIDATE,
            Self::GUARD_SIGN,
            Self::SOCIAL_PROVIDER,
        ]
    }
}
/// LimiterScope identifies the caller dimension that owns exhausted capacity.
/// It never contains the caller's actual identifier.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum LimiterScope {
    /// No limiter scope was provided.
    SCOPE_UNSPECIFIED = 0i32,
    /// The normalized client network address owns the capacity.
    CLIENT_IP = 1i32,
    /// The authenticated API key owns the capacity.
    API_KEY = 2i32,
    /// The authenticated account owns the capacity.
    ACCOUNT = 3i32,
    /// The selected subaccount owns the capacity.
    SUBACCOUNT = 4i32,
    /// The active realtime connection owns the capacity.
    CONNECTION = 5i32,
    /// The calling service owns the capacity.
    SERVICE = 6i32,
    /// The serving region owns the capacity.
    REGION = 7i32,
    /// The trading or market-data symbol owns the capacity.
    SYMBOL = 8i32,
    /// A privacy-preserving normalized public authentication subject owns capacity.
    AUTH_SUBJECT = 9i32,
}
impl LimiterScope {
    ///Idiomatic alias for [`Self::SCOPE_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ScopeUnspecified: Self = Self::SCOPE_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CLIENT_IP`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ClientIp: Self = Self::CLIENT_IP;
    ///Idiomatic alias for [`Self::API_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ApiKey: Self = Self::API_KEY;
    ///Idiomatic alias for [`Self::ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Account: Self = Self::ACCOUNT;
    ///Idiomatic alias for [`Self::SUBACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Subaccount: Self = Self::SUBACCOUNT;
    ///Idiomatic alias for [`Self::CONNECTION`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Connection: Self = Self::CONNECTION;
    ///Idiomatic alias for [`Self::SERVICE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Service: Self = Self::SERVICE;
    ///Idiomatic alias for [`Self::REGION`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Region: Self = Self::REGION;
    ///Idiomatic alias for [`Self::SYMBOL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Symbol: Self = Self::SYMBOL;
    ///Idiomatic alias for [`Self::AUTH_SUBJECT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const AuthSubject: Self = Self::AUTH_SUBJECT;
}
impl ::core::default::Default for LimiterScope {
    fn default() -> Self {
        Self::SCOPE_UNSPECIFIED
    }
}
impl ::serde::Serialize for LimiterScope {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        s.serialize_str(::buffa::Enumeration::proto_name(self))
    }
}
impl<'de> ::serde::Deserialize<'de> for LimiterScope {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = LimiterScope;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(LimiterScope)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<LimiterScope, E> {
                <LimiterScope as ::buffa::Enumeration>::from_proto_name(v)
                    .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
            }
            fn visit_i64<E: ::serde::de::Error>(
                self,
                v: i64,
            ) -> ::core::result::Result<LimiterScope, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <LimiterScope as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<LimiterScope, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <LimiterScope as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<LimiterScope, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for LimiterScope {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
impl ::buffa::Enumeration for LimiterScope {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::SCOPE_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::CLIENT_IP),
            2i32 => ::core::option::Option::Some(Self::API_KEY),
            3i32 => ::core::option::Option::Some(Self::ACCOUNT),
            4i32 => ::core::option::Option::Some(Self::SUBACCOUNT),
            5i32 => ::core::option::Option::Some(Self::CONNECTION),
            6i32 => ::core::option::Option::Some(Self::SERVICE),
            7i32 => ::core::option::Option::Some(Self::REGION),
            8i32 => ::core::option::Option::Some(Self::SYMBOL),
            9i32 => ::core::option::Option::Some(Self::AUTH_SUBJECT),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::SCOPE_UNSPECIFIED => "SCOPE_UNSPECIFIED",
            Self::CLIENT_IP => "CLIENT_IP",
            Self::API_KEY => "API_KEY",
            Self::ACCOUNT => "ACCOUNT",
            Self::SUBACCOUNT => "SUBACCOUNT",
            Self::CONNECTION => "CONNECTION",
            Self::SERVICE => "SERVICE",
            Self::REGION => "REGION",
            Self::SYMBOL => "SYMBOL",
            Self::AUTH_SUBJECT => "AUTH_SUBJECT",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "SCOPE_UNSPECIFIED" => ::core::option::Option::Some(Self::SCOPE_UNSPECIFIED),
            "CLIENT_IP" => ::core::option::Option::Some(Self::CLIENT_IP),
            "API_KEY" => ::core::option::Option::Some(Self::API_KEY),
            "ACCOUNT" => ::core::option::Option::Some(Self::ACCOUNT),
            "SUBACCOUNT" => ::core::option::Option::Some(Self::SUBACCOUNT),
            "CONNECTION" => ::core::option::Option::Some(Self::CONNECTION),
            "SERVICE" => ::core::option::Option::Some(Self::SERVICE),
            "REGION" => ::core::option::Option::Some(Self::REGION),
            "SYMBOL" => ::core::option::Option::Some(Self::SYMBOL),
            "AUTH_SUBJECT" => ::core::option::Option::Some(Self::AUTH_SUBJECT),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::SCOPE_UNSPECIFIED,
            Self::CLIENT_IP,
            Self::API_KEY,
            Self::ACCOUNT,
            Self::SUBACCOUNT,
            Self::CONNECTION,
            Self::SERVICE,
            Self::REGION,
            Self::SYMBOL,
            Self::AUTH_SUBJECT,
        ]
    }
}
/// RefillModel describes how exhausted capacity becomes available again.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum RefillModel {
    /// No refill model was provided.
    REFILL_UNSPECIFIED = 0i32,
    /// Capacity refills continuously over the configured policy period.
    CONTINUOUS = 1i32,
    /// Capacity resets at fixed window boundaries.
    FIXED_WINDOW = 2i32,
    /// Capacity is measured over a rolling time window.
    ROLLING_WINDOW = 3i32,
}
impl RefillModel {
    ///Idiomatic alias for [`Self::REFILL_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const RefillUnspecified: Self = Self::REFILL_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CONTINUOUS`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Continuous: Self = Self::CONTINUOUS;
    ///Idiomatic alias for [`Self::FIXED_WINDOW`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const FixedWindow: Self = Self::FIXED_WINDOW;
    ///Idiomatic alias for [`Self::ROLLING_WINDOW`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const RollingWindow: Self = Self::ROLLING_WINDOW;
}
impl ::core::default::Default for RefillModel {
    fn default() -> Self {
        Self::REFILL_UNSPECIFIED
    }
}
impl ::serde::Serialize for RefillModel {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        s.serialize_str(::buffa::Enumeration::proto_name(self))
    }
}
impl<'de> ::serde::Deserialize<'de> for RefillModel {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = RefillModel;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(RefillModel)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<RefillModel, E> {
                <RefillModel as ::buffa::Enumeration>::from_proto_name(v)
                    .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
            }
            fn visit_i64<E: ::serde::de::Error>(
                self,
                v: i64,
            ) -> ::core::result::Result<RefillModel, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <RefillModel as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<RefillModel, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <RefillModel as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("unknown enum value {v32}"),
                        )
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<RefillModel, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for RefillModel {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
impl ::buffa::Enumeration for RefillModel {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::REFILL_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::CONTINUOUS),
            2i32 => ::core::option::Option::Some(Self::FIXED_WINDOW),
            3i32 => ::core::option::Option::Some(Self::ROLLING_WINDOW),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::REFILL_UNSPECIFIED => "REFILL_UNSPECIFIED",
            Self::CONTINUOUS => "CONTINUOUS",
            Self::FIXED_WINDOW => "FIXED_WINDOW",
            Self::ROLLING_WINDOW => "ROLLING_WINDOW",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "REFILL_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::REFILL_UNSPECIFIED)
            }
            "CONTINUOUS" => ::core::option::Option::Some(Self::CONTINUOUS),
            "FIXED_WINDOW" => ::core::option::Option::Some(Self::FIXED_WINDOW),
            "ROLLING_WINDOW" => ::core::option::Option::Some(Self::ROLLING_WINDOW),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::REFILL_UNSPECIFIED,
            Self::CONTINUOUS,
            Self::FIXED_WINDOW,
            Self::ROLLING_WINDOW,
        ]
    }
}
/// RateLimitDetail contains bounded, client-safe quota state for one rejected
/// operation. Weight values use the operation registry's weighted request units.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct RateLimitDetail {
    /// Machine-readable failure reason.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<FailureReason>,
    /// Active weighted quota. Present for quota-exhaustion responses.
    ///
    /// Field 2: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub limit: ::core::option::Option<u64>,
    /// Weighted capacity remaining when the request was rejected.
    ///
    /// Field 3: `remaining`
    #[serde(
        rename = "remaining",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub remaining: ::core::option::Option<u64>,
    /// Minimum relative delay before retrying, in milliseconds.
    ///
    /// Field 4: `retry_after_ms`
    #[serde(
        rename = "retryAfterMs",
        alias = "retry_after_ms",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub retry_after_ms: ::core::option::Option<u64>,
    /// Policy version used for the decision, when available.
    ///
    /// Field 5: `policy_version`
    #[serde(
        rename = "policyVersion",
        alias = "policy_version",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub policy_version: ::core::option::Option<u64>,
    /// Stable operation identifier shared by all aliases of the same action.
    ///
    /// Field 6: `operation_id`
    #[serde(
        rename = "operationId",
        alias = "operation_id",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub operation_id: ::buffa::alloc::string::String,
    /// Mutable quota family used for the decision.
    ///
    /// Field 7: `policy_class`
    #[serde(
        rename = "policyClass",
        alias = "policy_class",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub policy_class: ::buffa::EnumValue<PolicyClass>,
    /// Caller dimension that owns the exhausted capacity.
    ///
    /// Field 8: `scope`
    #[serde(
        rename = "scope",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub scope: ::buffa::EnumValue<LimiterScope>,
    /// Refill behavior used by the active limiter.
    ///
    /// Field 9: `refill_model`
    #[serde(
        rename = "refillModel",
        alias = "refill_model",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub refill_model: ::buffa::EnumValue<RefillModel>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for RateLimitDetail {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("RateLimitDetail")
            .field("reason", &self.reason)
            .field("limit", &self.limit)
            .field("remaining", &self.remaining)
            .field("retry_after_ms", &self.retry_after_ms)
            .field("policy_version", &self.policy_version)
            .field("operation_id", &self.operation_id)
            .field("policy_class", &self.policy_class)
            .field("scope", &self.scope)
            .field("refill_model", &self.refill_model)
            .finish()
    }
}
impl RateLimitDetail {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/polyester.ratelimit.v1.RateLimitDetail";
}
impl RateLimitDetail {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::limit`] to `Some(value)`, consuming and returning `self`.
    pub fn with_limit(mut self, value: u64) -> Self {
        self.limit = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::remaining`] to `Some(value)`, consuming and returning `self`.
    pub fn with_remaining(mut self, value: u64) -> Self {
        self.remaining = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::retry_after_ms`] to `Some(value)`, consuming and returning `self`.
    pub fn with_retry_after_ms(mut self, value: u64) -> Self {
        self.retry_after_ms = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::policy_version`] to `Some(value)`, consuming and returning `self`.
    pub fn with_policy_version(mut self, value: u64) -> Self {
        self.policy_version = Some(value);
        self
    }
}
::buffa::impl_default_instance!(RateLimitDetail);
impl ::buffa::MessageName for RateLimitDetail {
    const PACKAGE: &'static str = "polyester.ratelimit.v1";
    const NAME: &'static str = "RateLimitDetail";
    const FULL_NAME: &'static str = "polyester.ratelimit.v1.RateLimitDetail";
    const TYPE_URL: &'static str = "type.googleapis.com/polyester.ratelimit.v1.RateLimitDetail";
}
impl ::buffa::Message for RateLimitDetail {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if let Some(v) = self.limit {
            size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
        }
        if let Some(v) = self.remaining {
            size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
        }
        if let Some(v) = self.retry_after_ms {
            size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
        }
        if let Some(v) = self.policy_version {
            size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
        }
        if !self.operation_id.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.operation_id) as u32;
        }
        {
            let val = self.policy_class.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.scope.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.refill_model.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if let Some(v) = self.limit {
            ::buffa::types::put_uint64_field(2u32, v, buf);
        }
        if let Some(v) = self.remaining {
            ::buffa::types::put_uint64_field(3u32, v, buf);
        }
        if let Some(v) = self.retry_after_ms {
            ::buffa::types::put_uint64_field(4u32, v, buf);
        }
        if let Some(v) = self.policy_version {
            ::buffa::types::put_uint64_field(5u32, v, buf);
        }
        if !self.operation_id.is_empty() {
            ::buffa::types::put_string_field(6u32, &self.operation_id, buf);
        }
        {
            let val = self.policy_class.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(7u32, val, buf);
            }
        }
        {
            let val = self.scope.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(8u32, val, buf);
            }
        }
        {
            let val = self.refill_model.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(9u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::core::option::Option::Some(
                    ::buffa::types::decode_uint64(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.remaining = ::core::option::Option::Some(
                    ::buffa::types::decode_uint64(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.retry_after_ms = ::core::option::Option::Some(
                    ::buffa::types::decode_uint64(buf)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.policy_version = ::core::option::Option::Some(
                    ::buffa::types::decode_uint64(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.operation_id, buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.policy_class = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.scope = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.refill_model = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.reason = ::buffa::EnumValue::from(0);
        self.limit = ::core::option::Option::None;
        self.remaining = ::core::option::Option::None;
        self.retry_after_ms = ::core::option::Option::None;
        self.policy_version = ::core::option::Option::None;
        self.operation_id.clear();
        self.policy_class = ::buffa::EnumValue::from(0);
        self.scope = ::buffa::EnumValue::from(0);
        self.refill_model = ::buffa::EnumValue::from(0);
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for RateLimitDetail {
    const PROTO_FQN: &'static str = "polyester.ratelimit.v1.RateLimitDetail";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for RateLimitDetail {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __RATE_LIMIT_DETAIL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/polyester.ratelimit.v1.RateLimitDetail",
    to_json: ::buffa::type_registry::any_to_json::<RateLimitDetail>,
    from_json: ::buffa::type_registry::any_from_json::<RateLimitDetail>,
    is_wkt: false,
};
#[allow(
    non_camel_case_types,
    dead_code,
    unused_imports,
    unused_qualifications,
    clippy::derivable_impls,
    clippy::match_single_binding,
    clippy::uninlined_format_args,
    clippy::doc_lazy_continuation,
    clippy::module_inception
)]
pub mod __buffa {
    #[allow(unused_imports)]
    use super::*;
    pub mod view {
        #[allow(unused_imports)]
        use super::*;
        /// RateLimitDetail contains bounded, client-safe quota state for one rejected
        /// operation. Weight values use the operation registry's weighted request units.
        #[derive(Clone, Debug, Default)]
        pub struct RateLimitDetailView<'a> {
            /// Machine-readable failure reason.
            ///
            /// Field 1: `reason`
            pub reason: ::buffa::EnumValue<super::super::FailureReason>,
            /// Active weighted quota. Present for quota-exhaustion responses.
            ///
            /// Field 2: `limit`
            pub limit: ::core::option::Option<u64>,
            /// Weighted capacity remaining when the request was rejected.
            ///
            /// Field 3: `remaining`
            pub remaining: ::core::option::Option<u64>,
            /// Minimum relative delay before retrying, in milliseconds.
            ///
            /// Field 4: `retry_after_ms`
            pub retry_after_ms: ::core::option::Option<u64>,
            /// Policy version used for the decision, when available.
            ///
            /// Field 5: `policy_version`
            pub policy_version: ::core::option::Option<u64>,
            /// Stable operation identifier shared by all aliases of the same action.
            ///
            /// Field 6: `operation_id`
            pub operation_id: &'a str,
            /// Mutable quota family used for the decision.
            ///
            /// Field 7: `policy_class`
            pub policy_class: ::buffa::EnumValue<super::super::PolicyClass>,
            /// Caller dimension that owns the exhausted capacity.
            ///
            /// Field 8: `scope`
            pub scope: ::buffa::EnumValue<super::super::LimiterScope>,
            /// Refill behavior used by the active limiter.
            ///
            /// Field 9: `refill_model`
            pub refill_model: ::buffa::EnumValue<super::super::RefillModel>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for RateLimitDetailView<'a> {
            type Owned = super::super::RateLimitDetail;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.reason = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = Some(::buffa::types::decode_uint64(&mut cur)?);
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.remaining = Some(::buffa::types::decode_uint64(&mut cur)?);
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.retry_after_ms = Some(
                            ::buffa::types::decode_uint64(&mut cur)?,
                        );
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.policy_version = Some(
                            ::buffa::types::decode_uint64(&mut cur)?,
                        );
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.operation_id = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.policy_class = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.scope = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.refill_model = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::RateLimitDetail,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::RateLimitDetail,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::RateLimitDetail {
                    reason: self.reason,
                    limit: self.limit,
                    remaining: self.remaining,
                    retry_after_ms: self.retry_after_ms,
                    policy_version: self.policy_version,
                    operation_id: self.operation_id.to_string(),
                    policy_class: self.policy_class,
                    scope: self.scope,
                    refill_model: self.refill_model,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for RateLimitDetailView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                {
                    let val = self.reason.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if let Some(v) = self.limit {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
                }
                if let Some(v) = self.remaining {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
                }
                if let Some(v) = self.retry_after_ms {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
                }
                if let Some(v) = self.policy_version {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
                }
                if !self.operation_id.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.operation_id)
                                as u32;
                }
                {
                    let val = self.policy_class.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.scope.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.refill_model.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                {
                    let val = self.reason.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, val, buf);
                    }
                }
                if let Some(v) = self.limit {
                    ::buffa::types::put_uint64_field(2u32, v, buf);
                }
                if let Some(v) = self.remaining {
                    ::buffa::types::put_uint64_field(3u32, v, buf);
                }
                if let Some(v) = self.retry_after_ms {
                    ::buffa::types::put_uint64_field(4u32, v, buf);
                }
                if let Some(v) = self.policy_version {
                    ::buffa::types::put_uint64_field(5u32, v, buf);
                }
                if !self.operation_id.is_empty() {
                    ::buffa::types::put_string_field(6u32, &self.operation_id, buf);
                }
                {
                    let val = self.policy_class.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(7u32, val, buf);
                    }
                }
                {
                    let val = self.scope.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(8u32, val, buf);
                    }
                }
                {
                    let val = self.refill_model.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(9u32, val, buf);
                    }
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for RateLimitDetailView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
                    __map.serialize_entry("reason", &self.reason)?;
                }
                if let ::core::option::Option::Some(__v) = self.limit {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if let ::core::option::Option::Some(__v) = self.remaining {
                    __map
                        .serialize_entry(
                            "remaining",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if let ::core::option::Option::Some(__v) = self.retry_after_ms {
                    __map
                        .serialize_entry(
                            "retryAfterMs",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if let ::core::option::Option::Some(__v) = self.policy_version {
                    __map
                        .serialize_entry(
                            "policyVersion",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.operation_id) {
                    __map.serialize_entry("operationId", self.operation_id)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.policy_class,
                ) {
                    __map.serialize_entry("policyClass", &self.policy_class)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.scope) {
                    __map.serialize_entry("scope", &self.scope)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.refill_model,
                ) {
                    __map.serialize_entry("refillModel", &self.refill_model)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for RateLimitDetailView<'a> {
            const PACKAGE: &'static str = "polyester.ratelimit.v1";
            const NAME: &'static str = "RateLimitDetail";
            const FULL_NAME: &'static str = "polyester.ratelimit.v1.RateLimitDetail";
            const TYPE_URL: &'static str = "type.googleapis.com/polyester.ratelimit.v1.RateLimitDetail";
        }
        ::buffa::impl_default_view_instance!(RateLimitDetailView);
        ::buffa::impl_view_reborrow!(RateLimitDetailView);
        /** Self-contained, `'static` owned view of a `RateLimitDetail` message.

 Wraps [`::buffa::OwnedView`]`<`[`RateLimitDetailView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`RateLimitDetailView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct RateLimitDetailOwnedView(
            ::buffa::OwnedView<RateLimitDetailView<'static>>,
        );
        impl RateLimitDetailOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    RateLimitDetailOwnedView(::buffa::OwnedView::decode(bytes)?),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    RateLimitDetailOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::RateLimitDetail,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    RateLimitDetailOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`RateLimitDetailView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &RateLimitDetailView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::RateLimitDetail,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// Machine-readable failure reason.
            ///
            /// Field 1: `reason`
            #[must_use]
            pub fn reason(&self) -> ::buffa::EnumValue<super::super::FailureReason> {
                self.0.reborrow().reason
            }
            /// Active weighted quota. Present for quota-exhaustion responses.
            ///
            /// Field 2: `limit`
            #[must_use]
            pub fn limit(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().limit
            }
            /// Weighted capacity remaining when the request was rejected.
            ///
            /// Field 3: `remaining`
            #[must_use]
            pub fn remaining(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().remaining
            }
            /// Minimum relative delay before retrying, in milliseconds.
            ///
            /// Field 4: `retry_after_ms`
            #[must_use]
            pub fn retry_after_ms(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().retry_after_ms
            }
            /// Policy version used for the decision, when available.
            ///
            /// Field 5: `policy_version`
            #[must_use]
            pub fn policy_version(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().policy_version
            }
            /// Stable operation identifier shared by all aliases of the same action.
            ///
            /// Field 6: `operation_id`
            #[must_use]
            pub fn operation_id(&self) -> &'_ str {
                self.0.reborrow().operation_id
            }
            /// Mutable quota family used for the decision.
            ///
            /// Field 7: `policy_class`
            #[must_use]
            pub fn policy_class(&self) -> ::buffa::EnumValue<super::super::PolicyClass> {
                self.0.reborrow().policy_class
            }
            /// Caller dimension that owns the exhausted capacity.
            ///
            /// Field 8: `scope`
            #[must_use]
            pub fn scope(&self) -> ::buffa::EnumValue<super::super::LimiterScope> {
                self.0.reborrow().scope
            }
            /// Refill behavior used by the active limiter.
            ///
            /// Field 9: `refill_model`
            #[must_use]
            pub fn refill_model(&self) -> ::buffa::EnumValue<super::super::RefillModel> {
                self.0.reborrow().refill_model
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<RateLimitDetailView<'static>>>
        for RateLimitDetailOwnedView {
            fn from(inner: ::buffa::OwnedView<RateLimitDetailView<'static>>) -> Self {
                RateLimitDetailOwnedView(inner)
            }
        }
        impl ::core::convert::From<RateLimitDetailOwnedView>
        for ::buffa::OwnedView<RateLimitDetailView<'static>> {
            fn from(wrapper: RateLimitDetailOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<RateLimitDetailView<'static>>>
        for RateLimitDetailOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<RateLimitDetailView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::RateLimitDetail {
            type View<'a> = RateLimitDetailView<'a>;
            type ViewHandle = RateLimitDetailOwnedView;
        }
        impl ::serde::Serialize for RateLimitDetailOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
    }
    /// Register this package's `Any` type entries and extension entries.
    pub fn register_types(reg: &mut ::buffa::type_registry::TypeRegistry) {
        reg.register_json_any(super::__RATE_LIMIT_DETAIL_JSON_ANY);
    }
}
#[doc(inline)]
pub use self::__buffa::view::RateLimitDetailView;
#[doc(inline)]
pub use self::__buffa::view::RateLimitDetailOwnedView;
#[doc(inline)]
pub use self::__buffa::register_types;