polyester/gen/buffa/

ledger.read.v1.rs

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

/// Supported history windows for balance charts.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum BalanceRange {
    RANGE_UNSPECIFIED = 0i32,
    /// 1 day
    DAY_1 = 1i32,
    /// 7 days
    DAY_7 = 2i32,
    /// 30 days
    DAY_30 = 3i32,
    /// 90 days
    DAY_90 = 4i32,
    /// 180 days
    DAY_180 = 5i32,
    /// 365 days
    DAY_365 = 6i32,
}
impl BalanceRange {
    ///Idiomatic alias for [`Self::RANGE_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const RangeUnspecified: Self = Self::RANGE_UNSPECIFIED;
    ///Idiomatic alias for [`Self::DAY_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day1: Self = Self::DAY_1;
    ///Idiomatic alias for [`Self::DAY_7`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day7: Self = Self::DAY_7;
    ///Idiomatic alias for [`Self::DAY_30`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day30: Self = Self::DAY_30;
    ///Idiomatic alias for [`Self::DAY_90`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day90: Self = Self::DAY_90;
    ///Idiomatic alias for [`Self::DAY_180`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day180: Self = Self::DAY_180;
    ///Idiomatic alias for [`Self::DAY_365`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day365: Self = Self::DAY_365;
}
impl ::core::default::Default for BalanceRange {
    fn default() -> Self {
        Self::RANGE_UNSPECIFIED
    }
}
impl ::serde::Serialize for BalanceRange {
    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 BalanceRange {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = BalanceRange;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(BalanceRange)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<BalanceRange, E> {
                <BalanceRange 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<BalanceRange, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <BalanceRange 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<BalanceRange, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <BalanceRange 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<BalanceRange, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for BalanceRange {
    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 BalanceRange {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::RANGE_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::DAY_1),
            2i32 => ::core::option::Option::Some(Self::DAY_7),
            3i32 => ::core::option::Option::Some(Self::DAY_30),
            4i32 => ::core::option::Option::Some(Self::DAY_90),
            5i32 => ::core::option::Option::Some(Self::DAY_180),
            6i32 => ::core::option::Option::Some(Self::DAY_365),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::RANGE_UNSPECIFIED => "RANGE_UNSPECIFIED",
            Self::DAY_1 => "DAY_1",
            Self::DAY_7 => "DAY_7",
            Self::DAY_30 => "DAY_30",
            Self::DAY_90 => "DAY_90",
            Self::DAY_180 => "DAY_180",
            Self::DAY_365 => "DAY_365",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "RANGE_UNSPECIFIED" => ::core::option::Option::Some(Self::RANGE_UNSPECIFIED),
            "DAY_1" => ::core::option::Option::Some(Self::DAY_1),
            "DAY_7" => ::core::option::Option::Some(Self::DAY_7),
            "DAY_30" => ::core::option::Option::Some(Self::DAY_30),
            "DAY_90" => ::core::option::Option::Some(Self::DAY_90),
            "DAY_180" => ::core::option::Option::Some(Self::DAY_180),
            "DAY_365" => ::core::option::Option::Some(Self::DAY_365),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::RANGE_UNSPECIFIED,
            Self::DAY_1,
            Self::DAY_7,
            Self::DAY_30,
            Self::DAY_90,
            Self::DAY_180,
            Self::DAY_365,
        ]
    }
}
/// How to group equity series data.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum EquityGroupBy {
    /// defaults to ACCOUNT
    GROUP_BY_UNSPECIFIED = 0i32,
    /// group by account bucket
    GROUP_BY_ACCOUNT = 1i32,
    /// group by asset (BTC, ETH, etc.)
    GROUP_BY_ASSET = 2i32,
}
impl EquityGroupBy {
    ///Idiomatic alias for [`Self::GROUP_BY_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const GroupByUnspecified: Self = Self::GROUP_BY_UNSPECIFIED;
    ///Idiomatic alias for [`Self::GROUP_BY_ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const GroupByAccount: Self = Self::GROUP_BY_ACCOUNT;
    ///Idiomatic alias for [`Self::GROUP_BY_ASSET`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const GroupByAsset: Self = Self::GROUP_BY_ASSET;
}
impl ::core::default::Default for EquityGroupBy {
    fn default() -> Self {
        Self::GROUP_BY_UNSPECIFIED
    }
}
impl ::serde::Serialize for EquityGroupBy {
    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 EquityGroupBy {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = EquityGroupBy;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(EquityGroupBy)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<EquityGroupBy, E> {
                <EquityGroupBy 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<EquityGroupBy, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <EquityGroupBy 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<EquityGroupBy, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <EquityGroupBy 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<EquityGroupBy, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for EquityGroupBy {
    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 EquityGroupBy {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::GROUP_BY_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::GROUP_BY_ACCOUNT),
            2i32 => ::core::option::Option::Some(Self::GROUP_BY_ASSET),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::GROUP_BY_UNSPECIFIED => "GROUP_BY_UNSPECIFIED",
            Self::GROUP_BY_ACCOUNT => "GROUP_BY_ACCOUNT",
            Self::GROUP_BY_ASSET => "GROUP_BY_ASSET",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "GROUP_BY_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::GROUP_BY_UNSPECIFIED)
            }
            "GROUP_BY_ACCOUNT" => ::core::option::Option::Some(Self::GROUP_BY_ACCOUNT),
            "GROUP_BY_ASSET" => ::core::option::Option::Some(Self::GROUP_BY_ASSET),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::GROUP_BY_UNSPECIFIED, Self::GROUP_BY_ACCOUNT, Self::GROUP_BY_ASSET]
    }
}
/// TransferSideKind identifies the display class for one side of a transfer.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum TransferSideKind {
    /// Transfer side type was not specified.
    TRANSFER_SIDE_KIND_UNSPECIFIED = 0i32,
    /// Polyester funding account.
    FUNDING_ACCOUNT = 1i32,
    /// Polyester trading account.
    TRADING_ACCOUNT = 2i32,
    /// External wallet or chain address. The address is lifecycle-derived and may
    /// be empty until ledger-to-lifecycle correlation is projected.
    EXTERNAL_ADDRESS = 3i32,
    /// Private off-chain counterparty that must not be identified to the caller.
    /// account_id and address are intentionally omitted.
    PRIVATE_COUNTERPARTY = 4i32,
    /// Fee ledger side, for example spot or perp trading fees.
    FEE_ACCOUNT = 5i32,
    /// System, operator, clearing, or other non-user side.
    SYSTEM_ACCOUNT = 6i32,
}
impl TransferSideKind {
    ///Idiomatic alias for [`Self::TRANSFER_SIDE_KIND_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TransferSideKindUnspecified: Self = Self::TRANSFER_SIDE_KIND_UNSPECIFIED;
    ///Idiomatic alias for [`Self::FUNDING_ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const FundingAccount: Self = Self::FUNDING_ACCOUNT;
    ///Idiomatic alias for [`Self::TRADING_ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TradingAccount: Self = Self::TRADING_ACCOUNT;
    ///Idiomatic alias for [`Self::EXTERNAL_ADDRESS`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ExternalAddress: Self = Self::EXTERNAL_ADDRESS;
    ///Idiomatic alias for [`Self::PRIVATE_COUNTERPARTY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PrivateCounterparty: Self = Self::PRIVATE_COUNTERPARTY;
    ///Idiomatic alias for [`Self::FEE_ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const FeeAccount: Self = Self::FEE_ACCOUNT;
    ///Idiomatic alias for [`Self::SYSTEM_ACCOUNT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SystemAccount: Self = Self::SYSTEM_ACCOUNT;
}
impl ::core::default::Default for TransferSideKind {
    fn default() -> Self {
        Self::TRANSFER_SIDE_KIND_UNSPECIFIED
    }
}
impl ::serde::Serialize for TransferSideKind {
    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 TransferSideKind {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = TransferSideKind;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(TransferSideKind)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<TransferSideKind, E> {
                <TransferSideKind 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<TransferSideKind, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <TransferSideKind 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<TransferSideKind, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <TransferSideKind 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<TransferSideKind, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for TransferSideKind {
    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 TransferSideKind {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::TRANSFER_SIDE_KIND_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::FUNDING_ACCOUNT),
            2i32 => ::core::option::Option::Some(Self::TRADING_ACCOUNT),
            3i32 => ::core::option::Option::Some(Self::EXTERNAL_ADDRESS),
            4i32 => ::core::option::Option::Some(Self::PRIVATE_COUNTERPARTY),
            5i32 => ::core::option::Option::Some(Self::FEE_ACCOUNT),
            6i32 => ::core::option::Option::Some(Self::SYSTEM_ACCOUNT),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::TRANSFER_SIDE_KIND_UNSPECIFIED => "TRANSFER_SIDE_KIND_UNSPECIFIED",
            Self::FUNDING_ACCOUNT => "FUNDING_ACCOUNT",
            Self::TRADING_ACCOUNT => "TRADING_ACCOUNT",
            Self::EXTERNAL_ADDRESS => "EXTERNAL_ADDRESS",
            Self::PRIVATE_COUNTERPARTY => "PRIVATE_COUNTERPARTY",
            Self::FEE_ACCOUNT => "FEE_ACCOUNT",
            Self::SYSTEM_ACCOUNT => "SYSTEM_ACCOUNT",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "TRANSFER_SIDE_KIND_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::TRANSFER_SIDE_KIND_UNSPECIFIED)
            }
            "FUNDING_ACCOUNT" => ::core::option::Option::Some(Self::FUNDING_ACCOUNT),
            "TRADING_ACCOUNT" => ::core::option::Option::Some(Self::TRADING_ACCOUNT),
            "EXTERNAL_ADDRESS" => ::core::option::Option::Some(Self::EXTERNAL_ADDRESS),
            "PRIVATE_COUNTERPARTY" => {
                ::core::option::Option::Some(Self::PRIVATE_COUNTERPARTY)
            }
            "FEE_ACCOUNT" => ::core::option::Option::Some(Self::FEE_ACCOUNT),
            "SYSTEM_ACCOUNT" => ::core::option::Option::Some(Self::SYSTEM_ACCOUNT),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::TRANSFER_SIDE_KIND_UNSPECIFIED,
            Self::FUNDING_ACCOUNT,
            Self::TRADING_ACCOUNT,
            Self::EXTERNAL_ADDRESS,
            Self::PRIVATE_COUNTERPARTY,
            Self::FEE_ACCOUNT,
            Self::SYSTEM_ACCOUNT,
        ]
    }
}
/// ErrorCode enumerates stable machine-readable error codes for the Ledger Read
/// API. These mirror the REST problem+json "code" field for parity between REST
/// and ConnectRPC clients.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum ErrorCode {
    ERROR_CODE_UNSPECIFIED = 0i32,
    ERROR_CODE_BAD_REQUEST = 1i32,
    ERROR_CODE_UNAUTHENTICATED = 2i32,
    ERROR_CODE_PERMISSION_DENIED = 3i32,
    ERROR_CODE_NOT_FOUND = 4i32,
    /// Missing or invalid account identifier (legacy; used by older endpoints).
    ERROR_CODE_MISSING_ACCOUNT_ID = 5i32,
    ERROR_CODE_INVALID_ACCOUNT_ID = 6i32,
    /// Wallet-specific errors for balance lookups by wallet.
    ERROR_CODE_MISSING_WALLET = 7i32,
    ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE = 8i32,
    ERROR_CODE_WALLET_NOT_FOUND = 9i32,
    /// Upstream dependency error (e.g., transfers store, wallet resolver).
    ERROR_CODE_UPSTREAM_ERROR = 10i32,
}
impl ErrorCode {
    ///Idiomatic alias for [`Self::ERROR_CODE_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::ERROR_CODE_UNSPECIFIED;
    ///Idiomatic alias for [`Self::ERROR_CODE_BAD_REQUEST`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BadRequest: Self = Self::ERROR_CODE_BAD_REQUEST;
    ///Idiomatic alias for [`Self::ERROR_CODE_UNAUTHENTICATED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unauthenticated: Self = Self::ERROR_CODE_UNAUTHENTICATED;
    ///Idiomatic alias for [`Self::ERROR_CODE_PERMISSION_DENIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PermissionDenied: Self = Self::ERROR_CODE_PERMISSION_DENIED;
    ///Idiomatic alias for [`Self::ERROR_CODE_NOT_FOUND`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const NotFound: Self = Self::ERROR_CODE_NOT_FOUND;
    ///Idiomatic alias for [`Self::ERROR_CODE_MISSING_ACCOUNT_ID`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MissingAccountId: Self = Self::ERROR_CODE_MISSING_ACCOUNT_ID;
    ///Idiomatic alias for [`Self::ERROR_CODE_INVALID_ACCOUNT_ID`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const InvalidAccountId: Self = Self::ERROR_CODE_INVALID_ACCOUNT_ID;
    ///Idiomatic alias for [`Self::ERROR_CODE_MISSING_WALLET`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MissingWallet: Self = Self::ERROR_CODE_MISSING_WALLET;
    ///Idiomatic alias for [`Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const WalletResolutionUnavailable: Self = Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE;
    ///Idiomatic alias for [`Self::ERROR_CODE_WALLET_NOT_FOUND`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const WalletNotFound: Self = Self::ERROR_CODE_WALLET_NOT_FOUND;
    ///Idiomatic alias for [`Self::ERROR_CODE_UPSTREAM_ERROR`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const UpstreamError: Self = Self::ERROR_CODE_UPSTREAM_ERROR;
}
impl ::core::default::Default for ErrorCode {
    fn default() -> Self {
        Self::ERROR_CODE_UNSPECIFIED
    }
}
impl ::serde::Serialize for ErrorCode {
    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 ErrorCode {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = ErrorCode;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(ErrorCode)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<ErrorCode, E> {
                <ErrorCode 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<ErrorCode, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <ErrorCode 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<ErrorCode, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <ErrorCode 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<ErrorCode, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ErrorCode {
    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 ErrorCode {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::ERROR_CODE_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::ERROR_CODE_BAD_REQUEST),
            2i32 => ::core::option::Option::Some(Self::ERROR_CODE_UNAUTHENTICATED),
            3i32 => ::core::option::Option::Some(Self::ERROR_CODE_PERMISSION_DENIED),
            4i32 => ::core::option::Option::Some(Self::ERROR_CODE_NOT_FOUND),
            5i32 => ::core::option::Option::Some(Self::ERROR_CODE_MISSING_ACCOUNT_ID),
            6i32 => ::core::option::Option::Some(Self::ERROR_CODE_INVALID_ACCOUNT_ID),
            7i32 => ::core::option::Option::Some(Self::ERROR_CODE_MISSING_WALLET),
            8i32 => {
                ::core::option::Option::Some(
                    Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE,
                )
            }
            9i32 => ::core::option::Option::Some(Self::ERROR_CODE_WALLET_NOT_FOUND),
            10i32 => ::core::option::Option::Some(Self::ERROR_CODE_UPSTREAM_ERROR),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::ERROR_CODE_UNSPECIFIED => "ERROR_CODE_UNSPECIFIED",
            Self::ERROR_CODE_BAD_REQUEST => "ERROR_CODE_BAD_REQUEST",
            Self::ERROR_CODE_UNAUTHENTICATED => "ERROR_CODE_UNAUTHENTICATED",
            Self::ERROR_CODE_PERMISSION_DENIED => "ERROR_CODE_PERMISSION_DENIED",
            Self::ERROR_CODE_NOT_FOUND => "ERROR_CODE_NOT_FOUND",
            Self::ERROR_CODE_MISSING_ACCOUNT_ID => "ERROR_CODE_MISSING_ACCOUNT_ID",
            Self::ERROR_CODE_INVALID_ACCOUNT_ID => "ERROR_CODE_INVALID_ACCOUNT_ID",
            Self::ERROR_CODE_MISSING_WALLET => "ERROR_CODE_MISSING_WALLET",
            Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE => {
                "ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE"
            }
            Self::ERROR_CODE_WALLET_NOT_FOUND => "ERROR_CODE_WALLET_NOT_FOUND",
            Self::ERROR_CODE_UPSTREAM_ERROR => "ERROR_CODE_UPSTREAM_ERROR",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "ERROR_CODE_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::ERROR_CODE_UNSPECIFIED)
            }
            "ERROR_CODE_BAD_REQUEST" => {
                ::core::option::Option::Some(Self::ERROR_CODE_BAD_REQUEST)
            }
            "ERROR_CODE_UNAUTHENTICATED" => {
                ::core::option::Option::Some(Self::ERROR_CODE_UNAUTHENTICATED)
            }
            "ERROR_CODE_PERMISSION_DENIED" => {
                ::core::option::Option::Some(Self::ERROR_CODE_PERMISSION_DENIED)
            }
            "ERROR_CODE_NOT_FOUND" => {
                ::core::option::Option::Some(Self::ERROR_CODE_NOT_FOUND)
            }
            "ERROR_CODE_MISSING_ACCOUNT_ID" => {
                ::core::option::Option::Some(Self::ERROR_CODE_MISSING_ACCOUNT_ID)
            }
            "ERROR_CODE_INVALID_ACCOUNT_ID" => {
                ::core::option::Option::Some(Self::ERROR_CODE_INVALID_ACCOUNT_ID)
            }
            "ERROR_CODE_MISSING_WALLET" => {
                ::core::option::Option::Some(Self::ERROR_CODE_MISSING_WALLET)
            }
            "ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE" => {
                ::core::option::Option::Some(
                    Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE,
                )
            }
            "ERROR_CODE_WALLET_NOT_FOUND" => {
                ::core::option::Option::Some(Self::ERROR_CODE_WALLET_NOT_FOUND)
            }
            "ERROR_CODE_UPSTREAM_ERROR" => {
                ::core::option::Option::Some(Self::ERROR_CODE_UPSTREAM_ERROR)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::ERROR_CODE_UNSPECIFIED,
            Self::ERROR_CODE_BAD_REQUEST,
            Self::ERROR_CODE_UNAUTHENTICATED,
            Self::ERROR_CODE_PERMISSION_DENIED,
            Self::ERROR_CODE_NOT_FOUND,
            Self::ERROR_CODE_MISSING_ACCOUNT_ID,
            Self::ERROR_CODE_INVALID_ACCOUNT_ID,
            Self::ERROR_CODE_MISSING_WALLET,
            Self::ERROR_CODE_WALLET_RESOLUTION_UNAVAILABLE,
            Self::ERROR_CODE_WALLET_NOT_FOUND,
            Self::ERROR_CODE_UPSTREAM_ERROR,
        ]
    }
}
/// Read surface for the Ledger (stable, versionable).
///
/// Canonical amounts are represented as integer quantities:
/// - IDs: fixed64/uint32
/// - Ledger amounts: U128 (hi/lo) at fixed 18-decimal scale
/// - Chart series: scaled integer vectors (e.g. *_q) with field-specific scales
///
/// REST JSON responses render
/// human-friendly decimal strings without duplicating REST message types here.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetBalancesRequest {
    /// Optional sub-account to scope balances to. If omitted, balances are
    /// returned for the authenticated root account derived from the JWT or API
    /// key. The logical account id itself is always derived from the caller's JWT
    /// or API key, not from this payload.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub subaccount_id: ::core::option::Option<u64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetBalancesRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetBalancesRequest")
            .field("subaccount_id", &self.subaccount_id)
            .finish()
    }
}
impl GetBalancesRequest {
    /// 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/ledger.read.v1.GetBalancesRequest";
}
impl GetBalancesRequest {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::subaccount_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_subaccount_id(mut self, value: u64) -> Self {
        self.subaccount_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(GetBalancesRequest);
impl ::buffa::MessageName for GetBalancesRequest {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetBalancesRequest";
    const FULL_NAME: &'static str = "ledger.read.v1.GetBalancesRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalancesRequest";
}
impl ::buffa::Message for GetBalancesRequest {
    /// 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;
        if self.subaccount_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN 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 _;
        if let Some(v) = self.subaccount_id {
            ::buffa::types::put_fixed64_field(1u32, v, 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::Fixed64,
                )?;
                self.subaccount_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetBalancesRequest {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetBalancesRequest";
    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 GetBalancesRequest {
    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 __GET_BALANCES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetBalancesRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetBalancesRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetBalancesRequest>,
    is_wkt: false,
};
/// Fixed-size representation for balances (for Protobuf/WS clients).
/// Uses common U128 messages for amounts to keep schema tidy and consistent.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct AssetBalance {
    /// Public unified asset id. Resolve symbol from SpotConfig; U128 amounts in
    /// this message always use fixed 18-decimal ledger scale.
    ///
    /// Field 1: `asset_id`
    #[serde(
        rename = "assetId",
        alias = "asset_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub asset_id: u32,
    /// Trading balance at fixed 18-decimal ledger scale.
    ///
    /// Field 2: `trading`
    #[serde(
        rename = "trading",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub trading: ::buffa::MessageField<super::super::super::polyester::r#type::v1::U128>,
    /// Funding balance at fixed 18-decimal ledger scale.
    ///
    /// Field 3: `funding`
    #[serde(
        rename = "funding",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub funding: ::buffa::MessageField<super::super::super::polyester::r#type::v1::U128>,
    /// Reserved amount in the trading bucket at fixed 18-decimal ledger scale.
    ///
    /// Field 4: `reserved`
    #[serde(
        rename = "reserved",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub reserved: ::buffa::MessageField<
        super::super::super::polyester::r#type::v1::U128,
    >,
    /// Amount currently available for new trading activity at fixed 18-decimal
    /// ledger scale. This value already accounts for active reservations.
    ///
    /// Field 5: `available`
    #[serde(
        rename = "available",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub available: ::buffa::MessageField<
        super::super::super::polyester::r#type::v1::U128,
    >,
    /// Opaque monotonic revision for the atomic trading, reserved, and available
    /// values. Higher means newer; zero means no trading state has been observed.
    ///
    /// Field 6: `trading_revision`
    #[serde(
        rename = "tradingRevision",
        alias = "trading_revision",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub trading_revision: u64,
    /// Opaque monotonic revision for the funding value. Higher means newer; zero
    /// means no funding state has been observed.
    ///
    /// Field 7: `funding_revision`
    #[serde(
        rename = "fundingRevision",
        alias = "funding_revision",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub funding_revision: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for AssetBalance {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("AssetBalance")
            .field("asset_id", &self.asset_id)
            .field("trading", &self.trading)
            .field("funding", &self.funding)
            .field("reserved", &self.reserved)
            .field("available", &self.available)
            .field("trading_revision", &self.trading_revision)
            .field("funding_revision", &self.funding_revision)
            .finish()
    }
}
impl AssetBalance {
    /// 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/ledger.read.v1.AssetBalance";
}
::buffa::impl_default_instance!(AssetBalance);
impl ::buffa::MessageName for AssetBalance {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "AssetBalance";
    const FULL_NAME: &'static str = "ledger.read.v1.AssetBalance";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AssetBalance";
}
impl ::buffa::Message for AssetBalance {
    /// 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;
        if self.asset_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
        }
        if self.trading.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.trading.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.funding.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.funding.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.reserved.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.reserved.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.available.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.available.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.trading_revision != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.trading_revision) as u32;
        }
        if self.funding_revision != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.funding_revision) 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 _;
        if self.asset_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
        }
        if self.trading.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.trading.write_to(__cache, buf);
        }
        if self.funding.is_set() {
            ::buffa::types::put_len_delimited_header(3u32, __cache.consume_next(), buf);
            self.funding.write_to(__cache, buf);
        }
        if self.reserved.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.reserved.write_to(__cache, buf);
        }
        if self.available.is_set() {
            ::buffa::types::put_len_delimited_header(5u32, __cache.consume_next(), buf);
            self.available.write_to(__cache, buf);
        }
        if self.trading_revision != 0u64 {
            ::buffa::types::put_uint64_field(6u32, self.trading_revision, buf);
        }
        if self.funding_revision != 0u64 {
            ::buffa::types::put_uint64_field(7u32, self.funding_revision, 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.asset_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.trading.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.funding.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.reserved.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.available.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.trading_revision = ::buffa::types::decode_uint64(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.funding_revision = ::buffa::types::decode_uint64(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.asset_id = 0u32;
        self.trading = ::buffa::MessageField::none();
        self.funding = ::buffa::MessageField::none();
        self.reserved = ::buffa::MessageField::none();
        self.available = ::buffa::MessageField::none();
        self.trading_revision = 0u64;
        self.funding_revision = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for AssetBalance {
    const PROTO_FQN: &'static str = "ledger.read.v1.AssetBalance";
    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 AssetBalance {
    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 __ASSET_BALANCE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.AssetBalance",
    to_json: ::buffa::type_registry::any_to_json::<AssetBalance>,
    from_json: ::buffa::type_registry::any_from_json::<AssetBalance>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetBalancesResponse {
    /// One entry for every supported unified asset, including assets with zero
    /// balances. Sorted by available trading amount (highest first), then by
    /// asset symbol alphabetically.
    ///
    /// Field 1: `balances`
    #[serde(
        rename = "balances",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub balances: ::buffa::alloc::vec::Vec<AssetBalance>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetBalancesResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetBalancesResponse").field("balances", &self.balances).finish()
    }
}
impl GetBalancesResponse {
    /// 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/ledger.read.v1.GetBalancesResponse";
}
::buffa::impl_default_instance!(GetBalancesResponse);
impl ::buffa::MessageName for GetBalancesResponse {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetBalancesResponse";
    const FULL_NAME: &'static str = "ledger.read.v1.GetBalancesResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalancesResponse";
}
impl ::buffa::Message for GetBalancesResponse {
    /// 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;
        for v in &self.balances {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        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 _;
        for v in &self.balances {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, 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::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.balances.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.balances.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetBalancesResponse {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetBalancesResponse";
    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 GetBalancesResponse {
    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 __GET_BALANCES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetBalancesResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetBalancesResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetBalancesResponse>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetBalanceHistoryRequest {
    /// Optional sub-account to scope balances to. If omitted, balances are
    /// returned for the authenticated root account derived from the JWT or API
    /// key. The logical account id itself is always derived from the caller's JWT
    /// or API key, not from this payload.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub subaccount_id: ::core::option::Option<u64>,
    /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
    ///
    /// Field 2: `range`
    #[serde(
        rename = "range",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub range: ::buffa::EnumValue<BalanceRange>,
    /// Optional public asset filter. When unset/0, returns all assets.
    ///
    /// Field 3: `ledger`
    #[serde(
        rename = "ledger",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub ledger: u32,
    /// Optional subset of account buckets to return. When empty, returns all
    /// account buckets.
    ///
    /// Field 4: `account_codes`
    #[serde(
        rename = "accountCodes",
        alias = "account_codes",
        with = "::buffa::json_helpers::repeated_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub account_codes: ::buffa::alloc::vec::Vec<
        ::buffa::EnumValue<super::super::v1::AccountCode>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetBalanceHistoryRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetBalanceHistoryRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("range", &self.range)
            .field("ledger", &self.ledger)
            .field("account_codes", &self.account_codes)
            .finish()
    }
}
impl GetBalanceHistoryRequest {
    /// 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/ledger.read.v1.GetBalanceHistoryRequest";
}
impl GetBalanceHistoryRequest {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::subaccount_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_subaccount_id(mut self, value: u64) -> Self {
        self.subaccount_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(GetBalanceHistoryRequest);
impl ::buffa::MessageName for GetBalanceHistoryRequest {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetBalanceHistoryRequest";
    const FULL_NAME: &'static str = "ledger.read.v1.GetBalanceHistoryRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalanceHistoryRequest";
}
impl ::buffa::Message for GetBalanceHistoryRequest {
    /// 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;
        if self.subaccount_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        {
            let val = self.range.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.ledger != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.ledger) as u32;
        }
        if !self.account_codes.is_empty() {
            let payload: u32 = self
                .account_codes
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        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 _;
        if let Some(v) = self.subaccount_id {
            ::buffa::types::put_fixed64_field(1u32, v, buf);
        }
        {
            let val = self.range.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if self.ledger != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.ledger, buf);
        }
        if !self.account_codes.is_empty() {
            let payload: u32 = self
                .account_codes
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(4u32, payload, buf);
            for v in &self.account_codes {
                ::buffa::types::encode_int32(v.to_i32(), 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::Fixed64,
                )?;
                self.subaccount_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.range = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ledger = ::buffa::types::decode_uint32(buf)?;
            }
            4u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.account_codes.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.account_codes
                            .push(
                                ::buffa::EnumValue::from(
                                    ::buffa::types::decode_int32(&mut limited)?,
                                ),
                            );
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.account_codes
                        .push(
                            ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?),
                        );
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = ::core::option::Option::None;
        self.range = ::buffa::EnumValue::from(0);
        self.ledger = 0u32;
        self.account_codes.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetBalanceHistoryRequest {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetBalanceHistoryRequest";
    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 GetBalanceHistoryRequest {
    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 __GET_BALANCE_HISTORY_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetBalanceHistoryRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetBalanceHistoryRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetBalanceHistoryRequest>,
    is_wkt: false,
};
/// Columnar balance series payload (scaled integers).
/// REST renders decimal strings from these values.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct BalanceSeries {
    /// public unified asset id
    ///
    /// Field 1: `asset_id`
    #[serde(
        rename = "assetId",
        alias = "asset_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub asset_id: u32,
    /// account bucket
    ///
    /// Field 2: `account_code`
    #[serde(
        rename = "accountCode",
        alias = "account_code",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub account_code: ::buffa::EnumValue<super::super::v1::AccountCode>,
    /// Chart balance in asset units scaled by 1e7 (7 decimals).
    /// Values are downscaled from 18-decimal ledger balances for compact charting
    /// and align 1:1 with implicit timestamps.
    ///
    /// Field 3: `balance_q`
    #[serde(
        rename = "balanceQ",
        alias = "balance_q",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub balance_q: ::buffa::alloc::vec::Vec<u64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for BalanceSeries {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("BalanceSeries")
            .field("asset_id", &self.asset_id)
            .field("account_code", &self.account_code)
            .field("balance_q", &self.balance_q)
            .finish()
    }
}
impl BalanceSeries {
    /// 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/ledger.read.v1.BalanceSeries";
}
::buffa::impl_default_instance!(BalanceSeries);
impl ::buffa::MessageName for BalanceSeries {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "BalanceSeries";
    const FULL_NAME: &'static str = "ledger.read.v1.BalanceSeries";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.BalanceSeries";
}
impl ::buffa::Message for BalanceSeries {
    /// 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;
        if self.asset_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
        }
        {
            let val = self.account_code.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.balance_q.is_empty() {
            let payload: u32 = self
                .balance_q
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        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 _;
        if self.asset_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
        }
        {
            let val = self.account_code.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if !self.balance_q.is_empty() {
            let payload: u32 = self
                .balance_q
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(3u32, payload, buf);
            for &v in &self.balance_q {
                ::buffa::types::encode_uint64(v, 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.asset_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.account_code = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.balance_q.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.balance_q
                            .push(::buffa::types::decode_uint64(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.balance_q.push(::buffa::types::decode_uint64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.asset_id = 0u32;
        self.account_code = ::buffa::EnumValue::from(0);
        self.balance_q.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for BalanceSeries {
    const PROTO_FQN: &'static str = "ledger.read.v1.BalanceSeries";
    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 BalanceSeries {
    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 __BALANCE_SERIES_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.BalanceSeries",
    to_json: ::buffa::type_registry::any_to_json::<BalanceSeries>,
    from_json: ::buffa::type_registry::any_from_json::<BalanceSeries>,
    is_wkt: false,
};
/// GetBalanceHistoryResponse returns aligned balance chart series.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetBalanceHistoryResponse {
    /// Resolved history window.
    ///
    /// Field 1: `range`
    #[serde(
        rename = "range",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub range: ::buffa::EnumValue<BalanceRange>,
    /// Sampling interval between points, such as "5m" or "1h".
    ///
    /// Field 2: `bucket`
    #[serde(
        rename = "bucket",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub bucket: ::buffa::alloc::string::String,
    /// First point timestamp in seconds since epoch (UTC).
    ///
    /// Field 3: `start_ts_sec`
    #[serde(
        rename = "startTsSec",
        alias = "start_ts_sec",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub start_ts_sec: u32,
    /// Last point timestamp in seconds since epoch (UTC).
    ///
    /// Field 4: `end_ts_sec`
    #[serde(
        rename = "endTsSec",
        alias = "end_ts_sec",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub end_ts_sec: u32,
    /// Number of aligned points in each returned series.
    ///
    /// Field 5: `points`
    #[serde(
        rename = "points",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub points: u32,
    /// Balance series ordered by asset ID, then account bucket.
    ///
    /// Field 6: `series`
    #[serde(
        rename = "series",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub series: ::buffa::alloc::vec::Vec<BalanceSeries>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetBalanceHistoryResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetBalanceHistoryResponse")
            .field("range", &self.range)
            .field("bucket", &self.bucket)
            .field("start_ts_sec", &self.start_ts_sec)
            .field("end_ts_sec", &self.end_ts_sec)
            .field("points", &self.points)
            .field("series", &self.series)
            .finish()
    }
}
impl GetBalanceHistoryResponse {
    /// 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/ledger.read.v1.GetBalanceHistoryResponse";
}
::buffa::impl_default_instance!(GetBalanceHistoryResponse);
impl ::buffa::MessageName for GetBalanceHistoryResponse {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetBalanceHistoryResponse";
    const FULL_NAME: &'static str = "ledger.read.v1.GetBalanceHistoryResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalanceHistoryResponse";
}
impl ::buffa::Message for GetBalanceHistoryResponse {
    /// 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.range.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.bucket.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.bucket) as u32;
        }
        if self.start_ts_sec != 0u32 {
            size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
        }
        if self.end_ts_sec != 0u32 {
            size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
        }
        if self.points != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.points) as u32;
        }
        for v in &self.series {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        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.range.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.bucket.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.bucket, buf);
        }
        if self.start_ts_sec != 0u32 {
            ::buffa::types::put_fixed32_field(3u32, self.start_ts_sec, buf);
        }
        if self.end_ts_sec != 0u32 {
            ::buffa::types::put_fixed32_field(4u32, self.end_ts_sec, buf);
        }
        if self.points != 0u32 {
            ::buffa::types::put_uint32_field(5u32, self.points, buf);
        }
        for v in &self.series {
            ::buffa::types::put_len_delimited_header(6u32, __cache.consume_next(), buf);
            v.write_to(__cache, 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.range = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.bucket, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed32,
                )?;
                self.start_ts_sec = ::buffa::types::decode_fixed32(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed32,
                )?;
                self.end_ts_sec = ::buffa::types::decode_fixed32(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.points = ::buffa::types::decode_uint32(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.series.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.range = ::buffa::EnumValue::from(0);
        self.bucket.clear();
        self.start_ts_sec = 0u32;
        self.end_ts_sec = 0u32;
        self.points = 0u32;
        self.series.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetBalanceHistoryResponse {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetBalanceHistoryResponse";
    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 GetBalanceHistoryResponse {
    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 __GET_BALANCE_HISTORY_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetBalanceHistoryResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetBalanceHistoryResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetBalanceHistoryResponse>,
    is_wkt: false,
};
/// Account grouping metadata (used when group_by = ACCOUNT).
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct AccountGrouping {
    /// account bucket code
    ///
    /// Field 1: `account_code`
    #[serde(
        rename = "accountCode",
        alias = "account_code",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub account_code: u32,
    /// human-readable name ("funding", "trading")
    ///
    /// Field 2: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for AccountGrouping {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("AccountGrouping")
            .field("account_code", &self.account_code)
            .field("name", &self.name)
            .finish()
    }
}
impl AccountGrouping {
    /// 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/ledger.read.v1.AccountGrouping";
}
::buffa::impl_default_instance!(AccountGrouping);
impl ::buffa::MessageName for AccountGrouping {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "AccountGrouping";
    const FULL_NAME: &'static str = "ledger.read.v1.AccountGrouping";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AccountGrouping";
}
impl ::buffa::Message for AccountGrouping {
    /// 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;
        if self.account_code != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.account_code) as u32;
        }
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) 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 _;
        if self.account_code != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.account_code, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.name, 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.account_code = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.account_code = 0u32;
        self.name.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for AccountGrouping {
    const PROTO_FQN: &'static str = "ledger.read.v1.AccountGrouping";
    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 AccountGrouping {
    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 __ACCOUNT_GROUPING_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.AccountGrouping",
    to_json: ::buffa::type_registry::any_to_json::<AccountGrouping>,
    from_json: ::buffa::type_registry::any_from_json::<AccountGrouping>,
    is_wkt: false,
};
/// Asset grouping metadata (used when group_by = ASSET).
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct AssetGrouping {
    /// public asset id (0 for "OTHER" bucket)
    ///
    /// Field 1: `id`
    #[serde(
        rename = "id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub id: u32,
    /// asset symbol ("BTC", "ETH", "OTHER")
    ///
    /// Field 2: `symbol`
    #[serde(
        rename = "symbol",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub symbol: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for AssetGrouping {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("AssetGrouping")
            .field("id", &self.id)
            .field("symbol", &self.symbol)
            .finish()
    }
}
impl AssetGrouping {
    /// 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/ledger.read.v1.AssetGrouping";
}
::buffa::impl_default_instance!(AssetGrouping);
impl ::buffa::MessageName for AssetGrouping {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "AssetGrouping";
    const FULL_NAME: &'static str = "ledger.read.v1.AssetGrouping";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AssetGrouping";
}
impl ::buffa::Message for AssetGrouping {
    /// 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;
        if self.id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.id) as u32;
        }
        if !self.symbol.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.symbol) 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 _;
        if self.id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.id, buf);
        }
        if !self.symbol.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.symbol, 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.id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.symbol, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.id = 0u32;
        self.symbol.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for AssetGrouping {
    const PROTO_FQN: &'static str = "ledger.read.v1.AssetGrouping";
    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 AssetGrouping {
    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 __ASSET_GROUPING_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.AssetGrouping",
    to_json: ::buffa::type_registry::any_to_json::<AssetGrouping>,
    from_json: ::buffa::type_registry::any_from_json::<AssetGrouping>,
    is_wkt: false,
};
/// Equity history in USDT (or BTC via client-side conversion using btc_prices).
/// Values are derived from per-asset balances and market prices (close ticks).
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetEquityHistorySeriesRequest {
    /// Optional sub-account to scope equity to. If omitted, equity is returned for
    /// the authenticated root account derived from the JWT or API key.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub subaccount_id: ::core::option::Option<u64>,
    /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
    ///
    /// Field 2: `range`
    #[serde(
        rename = "range",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub range: ::buffa::EnumValue<BalanceRange>,
    /// Optional subset of account buckets.
    /// When empty, server returns both funding and trading.
    /// Only used when group_by = ACCOUNT.
    ///
    /// Field 4: `account_codes`
    #[serde(
        rename = "accountCodes",
        alias = "account_codes",
        with = "::buffa::json_helpers::repeated_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub account_codes: ::buffa::alloc::vec::Vec<
        ::buffa::EnumValue<super::super::v1::AccountCode>,
    >,
    /// How to group the equity series. Defaults to ACCOUNT if unspecified.
    ///
    /// Field 5: `group_by`
    #[serde(
        rename = "groupBy",
        alias = "group_by",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub group_by: ::buffa::EnumValue<EquityGroupBy>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetEquityHistorySeriesRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetEquityHistorySeriesRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("range", &self.range)
            .field("account_codes", &self.account_codes)
            .field("group_by", &self.group_by)
            .finish()
    }
}
impl GetEquityHistorySeriesRequest {
    /// 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/ledger.read.v1.GetEquityHistorySeriesRequest";
}
impl GetEquityHistorySeriesRequest {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::subaccount_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_subaccount_id(mut self, value: u64) -> Self {
        self.subaccount_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(GetEquityHistorySeriesRequest);
impl ::buffa::MessageName for GetEquityHistorySeriesRequest {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetEquityHistorySeriesRequest";
    const FULL_NAME: &'static str = "ledger.read.v1.GetEquityHistorySeriesRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesRequest";
}
impl ::buffa::Message for GetEquityHistorySeriesRequest {
    /// 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;
        if self.subaccount_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        {
            let val = self.range.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.account_codes.is_empty() {
            let payload: u32 = self
                .account_codes
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        {
            let val = self.group_by.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 _;
        if let Some(v) = self.subaccount_id {
            ::buffa::types::put_fixed64_field(1u32, v, buf);
        }
        {
            let val = self.range.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if !self.account_codes.is_empty() {
            let payload: u32 = self
                .account_codes
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(4u32, payload, buf);
            for v in &self.account_codes {
                ::buffa::types::encode_int32(v.to_i32(), buf);
            }
        }
        {
            let val = self.group_by.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(5u32, 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::Fixed64,
                )?;
                self.subaccount_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.range = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            4u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.account_codes.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.account_codes
                            .push(
                                ::buffa::EnumValue::from(
                                    ::buffa::types::decode_int32(&mut limited)?,
                                ),
                            );
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.account_codes
                        .push(
                            ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?),
                        );
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.group_by = ::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.subaccount_id = ::core::option::Option::None;
        self.range = ::buffa::EnumValue::from(0);
        self.account_codes.clear();
        self.group_by = ::buffa::EnumValue::from(0);
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetEquityHistorySeriesRequest {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetEquityHistorySeriesRequest";
    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 GetEquityHistorySeriesRequest {
    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 __GET_EQUITY_HISTORY_SERIES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetEquityHistorySeriesRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetEquityHistorySeriesRequest>,
    is_wkt: false,
};
/// Columnar equity series payload (scaled integers).
/// REST renders decimal strings from these values.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default)]
pub struct EquitySeries {
    /// Equity in quote currency (USDT) scaled by 1e4 (4 decimals).
    /// Values align 1:1 with timestamps.
    ///
    /// Field 2: `equity_q`
    #[serde(
        rename = "equityQ",
        alias = "equity_q",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub equity_q: ::buffa::alloc::vec::Vec<i64>,
    #[serde(flatten)]
    pub grouping: ::core::option::Option<__buffa::oneof::equity_series::Grouping>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for EquitySeries {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("EquitySeries")
            .field("equity_q", &self.equity_q)
            .field("grouping", &self.grouping)
            .finish()
    }
}
impl EquitySeries {
    /// 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/ledger.read.v1.EquitySeries";
}
::buffa::impl_default_instance!(EquitySeries);
impl ::buffa::MessageName for EquitySeries {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "EquitySeries";
    const FULL_NAME: &'static str = "ledger.read.v1.EquitySeries";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.EquitySeries";
}
impl ::buffa::Message for EquitySeries {
    /// 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;
        if let ::core::option::Option::Some(ref v) = self.grouping {
            match v {
                __buffa::oneof::equity_series::Grouping::Account(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::equity_series::Grouping::Asset(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
            }
        }
        if !self.equity_q.is_empty() {
            let payload: u32 = self
                .equity_q
                .iter()
                .map(|&v| ::buffa::types::sint64_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        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 _;
        if let ::core::option::Option::Some(ref v) = self.grouping {
            match v {
                __buffa::oneof::equity_series::Grouping::Account(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::equity_series::Grouping::Asset(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        if !self.equity_q.is_empty() {
            let payload: u32 = self
                .equity_q
                .iter()
                .map(|&v| ::buffa::types::sint64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(2u32, payload, buf);
            for &v in &self.equity_q {
                ::buffa::types::encode_sint64(v, 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::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::equity_series::Grouping::Account(ref mut existing),
                ) = self.grouping
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.grouping = ::core::option::Option::Some(
                        __buffa::oneof::equity_series::Grouping::Account(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::equity_series::Grouping::Asset(ref mut existing),
                ) = self.grouping
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.grouping = ::core::option::Option::Some(
                        __buffa::oneof::equity_series::Grouping::Asset(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.equity_q.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.equity_q.push(::buffa::types::decode_sint64(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.equity_q.push(::buffa::types::decode_sint64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.grouping = ::core::option::Option::None;
        self.equity_q.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for EquitySeries {
    const PROTO_FQN: &'static str = "ledger.read.v1.EquitySeries";
    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<'de> serde::Deserialize<'de> for EquitySeries {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = EquitySeries;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct EquitySeries")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<EquitySeries, A::Error> {
                let mut __f_equity_q: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<i64>,
                > = None;
                let mut __oneof_grouping: ::core::option::Option<
                    __buffa::oneof::equity_series::Grouping,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "equityQ" | "equity_q" => {
                            __f_equity_q = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<i64>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<i64>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::proto_seq::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "account" => {
                            let v: ::core::option::Option<AccountGrouping> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            AccountGrouping,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_grouping.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'grouping'",
                                        ),
                                    );
                                }
                                __oneof_grouping = Some(
                                    __buffa::oneof::equity_series::Grouping::Account(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "asset" => {
                            let v: ::core::option::Option<AssetGrouping> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            AssetGrouping,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_grouping.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'grouping'",
                                        ),
                                    );
                                }
                                __oneof_grouping = Some(
                                    __buffa::oneof::equity_series::Grouping::Asset(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <EquitySeries as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_equity_q {
                    __r.equity_q = v;
                }
                __r.grouping = __oneof_grouping;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for EquitySeries {
    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 __EQUITY_SERIES_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.EquitySeries",
    to_json: ::buffa::type_registry::any_to_json::<EquitySeries>,
    from_json: ::buffa::type_registry::any_from_json::<EquitySeries>,
    is_wkt: false,
};
pub mod equity_series {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::equity_series::Grouping;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::equity_series::Grouping as GroupingView;
}
/// GetEquityHistorySeriesResponse returns aligned equity chart series.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetEquityHistorySeriesResponse {
    /// Resolved history window.
    ///
    /// Field 1: `range`
    #[serde(
        rename = "range",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub range: ::buffa::EnumValue<BalanceRange>,
    /// Sampling interval between points, such as "5m" or "1h".
    ///
    /// Field 2: `bucket`
    #[serde(
        rename = "bucket",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub bucket: ::buffa::alloc::string::String,
    /// First point timestamp in seconds since epoch (UTC).
    ///
    /// Field 3: `start_ts_sec`
    #[serde(
        rename = "startTsSec",
        alias = "start_ts_sec",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub start_ts_sec: u32,
    /// Last point timestamp in seconds since epoch (UTC).
    ///
    /// Field 4: `end_ts_sec`
    #[serde(
        rename = "endTsSec",
        alias = "end_ts_sec",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub end_ts_sec: u32,
    /// Human-readable quote asset symbol (always "USDT").
    ///
    /// Field 6: `quote_asset`
    #[serde(
        rename = "quoteAsset",
        alias = "quote_asset",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub quote_asset: ::buffa::alloc::string::String,
    /// Number of aligned points in each returned series.
    ///
    /// Field 7: `points`
    #[serde(
        rename = "points",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub points: u32,
    /// Equity series ordered by grouping identifier ascending.
    ///
    /// Field 8: `series`
    #[serde(
        rename = "series",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub series: ::buffa::alloc::vec::Vec<EquitySeries>,
    /// BTC-USDT close price at each timestamp, scaled by 1e6 (same as price_ticks).
    /// Enables client-side conversion to BTC denomination without refetch.
    ///
    /// Field 10: `btc_prices_q`
    #[serde(
        rename = "btcPricesQ",
        alias = "btc_prices_q",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub btc_prices_q: ::buffa::alloc::vec::Vec<i64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetEquityHistorySeriesResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetEquityHistorySeriesResponse")
            .field("range", &self.range)
            .field("bucket", &self.bucket)
            .field("start_ts_sec", &self.start_ts_sec)
            .field("end_ts_sec", &self.end_ts_sec)
            .field("quote_asset", &self.quote_asset)
            .field("points", &self.points)
            .field("series", &self.series)
            .field("btc_prices_q", &self.btc_prices_q)
            .finish()
    }
}
impl GetEquityHistorySeriesResponse {
    /// 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/ledger.read.v1.GetEquityHistorySeriesResponse";
}
::buffa::impl_default_instance!(GetEquityHistorySeriesResponse);
impl ::buffa::MessageName for GetEquityHistorySeriesResponse {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "GetEquityHistorySeriesResponse";
    const FULL_NAME: &'static str = "ledger.read.v1.GetEquityHistorySeriesResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesResponse";
}
impl ::buffa::Message for GetEquityHistorySeriesResponse {
    /// 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.range.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.bucket.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.bucket) as u32;
        }
        if self.start_ts_sec != 0u32 {
            size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
        }
        if self.end_ts_sec != 0u32 {
            size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
        }
        if !self.quote_asset.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.quote_asset) as u32;
        }
        if self.points != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.points) as u32;
        }
        for v in &self.series {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if !self.btc_prices_q.is_empty() {
            let payload: u32 = self
                .btc_prices_q
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        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.range.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.bucket.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.bucket, buf);
        }
        if self.start_ts_sec != 0u32 {
            ::buffa::types::put_fixed32_field(3u32, self.start_ts_sec, buf);
        }
        if self.end_ts_sec != 0u32 {
            ::buffa::types::put_fixed32_field(4u32, self.end_ts_sec, buf);
        }
        if !self.quote_asset.is_empty() {
            ::buffa::types::put_string_field(6u32, &self.quote_asset, buf);
        }
        if self.points != 0u32 {
            ::buffa::types::put_uint32_field(7u32, self.points, buf);
        }
        for v in &self.series {
            ::buffa::types::put_len_delimited_header(8u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if !self.btc_prices_q.is_empty() {
            let payload: u32 = self
                .btc_prices_q
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(10u32, payload, buf);
            for &v in &self.btc_prices_q {
                ::buffa::types::encode_int64(v, 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.range = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.bucket, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed32,
                )?;
                self.start_ts_sec = ::buffa::types::decode_fixed32(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed32,
                )?;
                self.end_ts_sec = ::buffa::types::decode_fixed32(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.quote_asset, buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.points = ::buffa::types::decode_uint32(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.series.push(elem);
            }
            10u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.btc_prices_q.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.btc_prices_q
                            .push(::buffa::types::decode_int64(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.btc_prices_q.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.range = ::buffa::EnumValue::from(0);
        self.bucket.clear();
        self.start_ts_sec = 0u32;
        self.end_ts_sec = 0u32;
        self.quote_asset.clear();
        self.points = 0u32;
        self.series.clear();
        self.btc_prices_q.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetEquityHistorySeriesResponse {
    const PROTO_FQN: &'static str = "ledger.read.v1.GetEquityHistorySeriesResponse";
    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 GetEquityHistorySeriesResponse {
    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 __GET_EQUITY_HISTORY_SERIES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetEquityHistorySeriesResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetEquityHistorySeriesResponse>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListTransfersRequest {
    /// Optional sub-account to scope transfers to. If omitted, transfers are
    /// listed for the authenticated root account derived from the JWT or API key.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub subaccount_id: ::core::option::Option<u64>,
    /// Maximum number of transfer rows to return. Defaults to 100 when omitted;
    /// maximum is 1000.
    ///
    /// Field 2: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// Sort direction. When true, rows are returned newest first; when false,
    /// rows are returned oldest first.
    ///
    /// Field 3: `reversed`
    #[serde(
        rename = "reversed",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub reversed: bool,
    /// Optional lower transfer timestamp bound in microseconds since epoch (UTC),
    /// inclusive.
    ///
    /// Field 4: `ts_min_us`
    #[serde(
        rename = "tsMinUs",
        alias = "ts_min_us",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_min_us: u64,
    /// Optional upper transfer timestamp bound in microseconds since epoch (UTC),
    /// inclusive.
    ///
    /// Field 5: `ts_max_us`
    #[serde(
        rename = "tsMaxUs",
        alias = "ts_max_us",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_max_us: u64,
    /// Optional filter by transfer reason.
    ///
    /// Field 6: `transfer_code`
    #[serde(
        rename = "transferCode",
        alias = "transfer_code",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub transfer_code: ::buffa::EnumValue<super::super::v1::TransferCode>,
    /// Optional filter by asset ledger.
    ///
    /// Field 7: `ledger`
    #[serde(
        rename = "ledger",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub ledger: u32,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to the authenticated account, sub-account scope, filters, timestamp
    /// bounds, and sort direction.
    ///
    /// Field 9: `page_token`
    #[serde(
        rename = "pageToken",
        alias = "page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListTransfersRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListTransfersRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("limit", &self.limit)
            .field("reversed", &self.reversed)
            .field("ts_min_us", &self.ts_min_us)
            .field("ts_max_us", &self.ts_max_us)
            .field("transfer_code", &self.transfer_code)
            .field("ledger", &self.ledger)
            .field("page_token", &self.page_token)
            .finish()
    }
}
impl ListTransfersRequest {
    /// 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/ledger.read.v1.ListTransfersRequest";
}
impl ListTransfersRequest {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::subaccount_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_subaccount_id(mut self, value: u64) -> Self {
        self.subaccount_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(ListTransfersRequest);
impl ::buffa::MessageName for ListTransfersRequest {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "ListTransfersRequest";
    const FULL_NAME: &'static str = "ledger.read.v1.ListTransfersRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListTransfersRequest";
}
impl ::buffa::Message for ListTransfersRequest {
    /// 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;
        if self.subaccount_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if self.reversed {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.ts_min_us != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_min_us) as u32;
        }
        if self.ts_max_us != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_max_us) as u32;
        }
        {
            let val = self.transfer_code.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.ledger != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.ledger) as u32;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) 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 _;
        if let Some(v) = self.subaccount_id {
            ::buffa::types::put_fixed64_field(1u32, v, buf);
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.limit, buf);
        }
        if self.reversed {
            ::buffa::types::put_bool_field(3u32, self.reversed, buf);
        }
        if self.ts_min_us != 0u64 {
            ::buffa::types::put_uint64_field(4u32, self.ts_min_us, buf);
        }
        if self.ts_max_us != 0u64 {
            ::buffa::types::put_uint64_field(5u32, self.ts_max_us, buf);
        }
        {
            let val = self.transfer_code.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(6u32, val, buf);
            }
        }
        if self.ledger != 0u32 {
            ::buffa::types::put_uint32_field(7u32, self.ledger, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(9u32, &self.page_token, 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::Fixed64,
                )?;
                self.subaccount_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.reversed = ::buffa::types::decode_bool(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_min_us = ::buffa::types::decode_uint64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_max_us = ::buffa::types::decode_uint64(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.transfer_code = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ledger = ::buffa::types::decode_uint32(buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = ::core::option::Option::None;
        self.limit = 0u32;
        self.reversed = false;
        self.ts_min_us = 0u64;
        self.ts_max_us = 0u64;
        self.transfer_code = ::buffa::EnumValue::from(0);
        self.ledger = 0u32;
        self.page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListTransfersRequest {
    const PROTO_FQN: &'static str = "ledger.read.v1.ListTransfersRequest";
    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 ListTransfersRequest {
    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 __LIST_TRANSFERS_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.ListTransfersRequest",
    to_json: ::buffa::type_registry::any_to_json::<ListTransfersRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ListTransfersRequest>,
    is_wkt: false,
};
/// TransferSide describes one side of a ledger transfer for display.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct TransferSide {
    /// Display classification for this transfer side.
    ///
    /// Field 1: `kind`
    #[serde(
        rename = "kind",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub kind: ::buffa::EnumValue<TransferSideKind>,
    /// Public root account or subaccount ID when this side is safe to identify. Never
    /// populated for private counterparties or non-user ledger accounts.
    ///
    /// Field 2: `account_id`
    #[serde(
        rename = "accountId",
        alias = "account_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub account_id: ::core::option::Option<u64>,
    /// Address for this side when known. For EXTERNAL_ADDRESS this is an
    /// external-chain wallet address from lifecycle correlation; for identifiable
    /// Polyester accounts this is a Polyester smart-account address.
    /// May be empty until the corresponding lifecycle details are available.
    ///
    /// Field 3: `address`
    #[serde(
        rename = "address",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub address: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for TransferSide {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("TransferSide")
            .field("kind", &self.kind)
            .field("account_id", &self.account_id)
            .field("address", &self.address)
            .finish()
    }
}
impl TransferSide {
    /// 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/ledger.read.v1.TransferSide";
}
impl TransferSide {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::account_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_account_id(mut self, value: u64) -> Self {
        self.account_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(TransferSide);
impl ::buffa::MessageName for TransferSide {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "TransferSide";
    const FULL_NAME: &'static str = "ledger.read.v1.TransferSide";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.TransferSide";
}
impl ::buffa::Message for TransferSide {
    /// 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.kind.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.account_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if !self.address.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.address) 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.kind.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if let Some(v) = self.account_id {
            ::buffa::types::put_fixed64_field(2u32, v, buf);
        }
        if !self.address.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.address, 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.kind = ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?);
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed64,
                )?;
                self.account_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.address, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.kind = ::buffa::EnumValue::from(0);
        self.account_id = ::core::option::Option::None;
        self.address.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for TransferSide {
    const PROTO_FQN: &'static str = "ledger.read.v1.TransferSide";
    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 TransferSide {
    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 __TRANSFER_SIDE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.TransferSide",
    to_json: ::buffa::type_registry::any_to_json::<TransferSide>,
    from_json: ::buffa::type_registry::any_from_json::<TransferSide>,
    is_wkt: false,
};
/// TransferRow describes one debit or credit leg of a ledger transfer.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct TransferRow {
    /// Public unified asset ID. Resolve its symbol through the spot configuration
    /// API. U128 amounts in this row always use a fixed 18-decimal ledger scale.
    ///
    /// Field 1: `asset_id`
    #[serde(
        rename = "assetId",
        alias = "asset_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub asset_id: u32,
    /// Transfer amount at fixed 18-decimal ledger scale.
    ///
    /// Field 2: `amount_e18`
    #[serde(
        rename = "amountE18",
        alias = "amount_e18",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub amount_e18: ::buffa::MessageField<
        super::super::super::polyester::r#type::v1::U128,
    >,
    /// Product reason for this transfer.
    ///
    /// Field 3: `transfer_code`
    #[serde(
        rename = "transferCode",
        alias = "transfer_code",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub transfer_code: ::buffa::EnumValue<super::super::v1::TransferCode>,
    /// Account bucket affected by this transfer.
    ///
    /// Field 4: `account_code`
    #[serde(
        rename = "accountCode",
        alias = "account_code",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub account_code: ::buffa::EnumValue<super::super::v1::AccountCode>,
    /// Transfer timestamp in microseconds since epoch (UTC).
    ///
    /// Field 5: `ts_us`
    #[serde(
        rename = "tsUs",
        alias = "ts_us",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_us: u64,
    /// Post-transfer balance at fixed 18-decimal ledger scale.
    ///
    /// Field 9: `balance_after_e18`
    #[serde(
        rename = "balanceAfterE18",
        alias = "balance_after_e18",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub balance_after_e18: ::buffa::MessageField<
        super::super::super::polyester::r#type::v1::U128,
    >,
    /// True when this row is the debit leg; false when it is the credit leg.
    ///
    /// Field 10: `is_debit`
    #[serde(
        rename = "isDebit",
        alias = "is_debit",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub is_debit: bool,
    /// Correlation ID used to group related transfer legs. Zero when unavailable.
    ///
    /// Field 11: `link_id`
    #[serde(
        rename = "linkId",
        alias = "link_id",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub link_id: u64,
    /// Public lifecycle flow ID when this transfer belongs to a chain lifecycle flow.
    ///
    /// Field 12: `flow_id`
    #[serde(
        rename = "flowId",
        alias = "flow_id",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub flow_id: ::buffa::alloc::string::String,
    /// Debit side of the transfer. This relationship is debit-to-credit rather
    /// than row-relative; use is_debit to determine whether this row is the debit leg.
    ///
    /// Field 13: `source`
    #[serde(
        rename = "source",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub source: ::buffa::MessageField<TransferSide>,
    /// Credit side of the transfer. This relationship is debit-to-credit rather
    /// than row-relative; use is_debit to determine whether this row is the credit leg.
    ///
    /// Field 14: `destination`
    #[serde(
        rename = "destination",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub destination: ::buffa::MessageField<TransferSide>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for TransferRow {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("TransferRow")
            .field("asset_id", &self.asset_id)
            .field("amount_e18", &self.amount_e18)
            .field("transfer_code", &self.transfer_code)
            .field("account_code", &self.account_code)
            .field("ts_us", &self.ts_us)
            .field("balance_after_e18", &self.balance_after_e18)
            .field("is_debit", &self.is_debit)
            .field("link_id", &self.link_id)
            .field("flow_id", &self.flow_id)
            .field("source", &self.source)
            .field("destination", &self.destination)
            .finish()
    }
}
impl TransferRow {
    /// 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/ledger.read.v1.TransferRow";
}
::buffa::impl_default_instance!(TransferRow);
impl ::buffa::MessageName for TransferRow {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "TransferRow";
    const FULL_NAME: &'static str = "ledger.read.v1.TransferRow";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.TransferRow";
}
impl ::buffa::Message for TransferRow {
    /// 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;
        if self.asset_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
        }
        if self.amount_e18.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.amount_e18.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        {
            let val = self.transfer_code.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.account_code.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.ts_us != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_us) as u32;
        }
        if self.balance_after_e18.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.balance_after_e18.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.is_debit {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.link_id != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.link_id) as u32;
        }
        if !self.flow_id.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.flow_id) as u32;
        }
        if self.source.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.source.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.destination.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.destination.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        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 _;
        if self.asset_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
        }
        if self.amount_e18.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.amount_e18.write_to(__cache, buf);
        }
        {
            let val = self.transfer_code.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(3u32, val, buf);
            }
        }
        {
            let val = self.account_code.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(4u32, val, buf);
            }
        }
        if self.ts_us != 0u64 {
            ::buffa::types::put_uint64_field(5u32, self.ts_us, buf);
        }
        if self.balance_after_e18.is_set() {
            ::buffa::types::put_len_delimited_header(9u32, __cache.consume_next(), buf);
            self.balance_after_e18.write_to(__cache, buf);
        }
        if self.is_debit {
            ::buffa::types::put_bool_field(10u32, self.is_debit, buf);
        }
        if self.link_id != 0u64 {
            ::buffa::types::put_uint64_field(11u32, self.link_id, buf);
        }
        if !self.flow_id.is_empty() {
            ::buffa::types::put_string_field(12u32, &self.flow_id, buf);
        }
        if self.source.is_set() {
            ::buffa::types::put_len_delimited_header(13u32, __cache.consume_next(), buf);
            self.source.write_to(__cache, buf);
        }
        if self.destination.is_set() {
            ::buffa::types::put_len_delimited_header(14u32, __cache.consume_next(), buf);
            self.destination.write_to(__cache, 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.asset_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.amount_e18.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.transfer_code = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.account_code = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_us = ::buffa::types::decode_uint64(buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.balance_after_e18.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_debit = ::buffa::types::decode_bool(buf)?;
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.link_id = ::buffa::types::decode_uint64(buf)?;
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.flow_id, buf)?;
            }
            13u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.source.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            14u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.destination.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.asset_id = 0u32;
        self.amount_e18 = ::buffa::MessageField::none();
        self.transfer_code = ::buffa::EnumValue::from(0);
        self.account_code = ::buffa::EnumValue::from(0);
        self.ts_us = 0u64;
        self.balance_after_e18 = ::buffa::MessageField::none();
        self.is_debit = false;
        self.link_id = 0u64;
        self.flow_id.clear();
        self.source = ::buffa::MessageField::none();
        self.destination = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for TransferRow {
    const PROTO_FQN: &'static str = "ledger.read.v1.TransferRow";
    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 TransferRow {
    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 __TRANSFER_ROW_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.TransferRow",
    to_json: ::buffa::type_registry::any_to_json::<TransferRow>,
    from_json: ::buffa::type_registry::any_from_json::<TransferRow>,
    is_wkt: false,
};
/// ListTransfersResponse contains transfer rows and an optional continuation cursor.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListTransfersResponse {
    /// Transfer rows in requested order.
    ///
    /// Field 1: `transfers`
    #[serde(
        rename = "transfers",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub transfers: ::buffa::alloc::vec::Vec<TransferRow>,
    /// Opaque cursor for the next page. Empty when no more results exist.
    ///
    /// Field 3: `next_page_token`
    #[serde(
        rename = "nextPageToken",
        alias = "next_page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub next_page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListTransfersResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListTransfersResponse")
            .field("transfers", &self.transfers)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl ListTransfersResponse {
    /// 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/ledger.read.v1.ListTransfersResponse";
}
::buffa::impl_default_instance!(ListTransfersResponse);
impl ::buffa::MessageName for ListTransfersResponse {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "ListTransfersResponse";
    const FULL_NAME: &'static str = "ledger.read.v1.ListTransfersResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListTransfersResponse";
}
impl ::buffa::Message for ListTransfersResponse {
    /// 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;
        for v in &self.transfers {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if !self.next_page_token.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.next_page_token) 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 _;
        for v in &self.transfers {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if !self.next_page_token.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.next_page_token, 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::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.transfers.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.next_page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.transfers.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListTransfersResponse {
    const PROTO_FQN: &'static str = "ledger.read.v1.ListTransfersResponse";
    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 ListTransfersResponse {
    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 __LIST_TRANSFERS_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.ListTransfersResponse",
    to_json: ::buffa::type_registry::any_to_json::<ListTransfersResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ListTransfersResponse>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListHoldsRequest {
    /// Optional sub-account to scope holds to. If omitted, holds are listed for
    /// the authenticated root account derived from the JWT or API key.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::opt_uint64",
        skip_serializing_if = "::core::option::Option::is_none"
    )]
    pub subaccount_id: ::core::option::Option<u64>,
    /// Maximum number of holds to return. Defaults to 100 when omitted; maximum is
    /// 1000.
    ///
    /// Field 2: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// true=newest first; false=oldest first.
    ///
    /// Field 3: `reversed`
    #[serde(
        rename = "reversed",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub reversed: bool,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to account, sub-account scope, and sort direction.
    ///
    /// Field 4: `page_token`
    #[serde(
        rename = "pageToken",
        alias = "page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListHoldsRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListHoldsRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("limit", &self.limit)
            .field("reversed", &self.reversed)
            .field("page_token", &self.page_token)
            .finish()
    }
}
impl ListHoldsRequest {
    /// 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/ledger.read.v1.ListHoldsRequest";
}
impl ListHoldsRequest {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::subaccount_id`] to `Some(value)`, consuming and returning `self`.
    pub fn with_subaccount_id(mut self, value: u64) -> Self {
        self.subaccount_id = Some(value);
        self
    }
}
::buffa::impl_default_instance!(ListHoldsRequest);
impl ::buffa::MessageName for ListHoldsRequest {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "ListHoldsRequest";
    const FULL_NAME: &'static str = "ledger.read.v1.ListHoldsRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListHoldsRequest";
}
impl ::buffa::Message for ListHoldsRequest {
    /// 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;
        if self.subaccount_id.is_some() {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if self.reversed {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) 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 _;
        if let Some(v) = self.subaccount_id {
            ::buffa::types::put_fixed64_field(1u32, v, buf);
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.limit, buf);
        }
        if self.reversed {
            ::buffa::types::put_bool_field(3u32, self.reversed, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(4u32, &self.page_token, 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::Fixed64,
                )?;
                self.subaccount_id = ::core::option::Option::Some(
                    ::buffa::types::decode_fixed64(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.reversed = ::buffa::types::decode_bool(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = ::core::option::Option::None;
        self.limit = 0u32;
        self.reversed = false;
        self.page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListHoldsRequest {
    const PROTO_FQN: &'static str = "ledger.read.v1.ListHoldsRequest";
    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 ListHoldsRequest {
    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 __LIST_HOLDS_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.ListHoldsRequest",
    to_json: ::buffa::type_registry::any_to_json::<ListHoldsRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ListHoldsRequest>,
    is_wkt: false,
};
/// Hold row with compact integers and client-side resolution.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HoldRow {
    /// pending transfer id (numeric)
    ///
    /// Field 1: `hold_id`
    #[serde(
        rename = "holdId",
        alias = "hold_id",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub hold_id: u64,
    /// Reserved amount at fixed 18-decimal ledger scale.
    ///
    /// Field 2: `amount_reserved_e18`
    #[serde(
        rename = "amountReservedE18",
        alias = "amount_reserved_e18",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub amount_reserved_e18: ::buffa::MessageField<
        super::super::super::polyester::r#type::v1::U128,
    >,
    /// Public unified asset id.
    ///
    /// Field 3: `asset_id`
    #[serde(
        rename = "assetId",
        alias = "asset_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub asset_id: u32,
    /// Expiration time in nanoseconds since epoch (UTC).
    ///
    /// Field 4: `expires_at_ns`
    #[serde(
        rename = "expiresAtNs",
        alias = "expires_at_ns",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub expires_at_ns: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HoldRow {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HoldRow")
            .field("hold_id", &self.hold_id)
            .field("amount_reserved_e18", &self.amount_reserved_e18)
            .field("asset_id", &self.asset_id)
            .field("expires_at_ns", &self.expires_at_ns)
            .finish()
    }
}
impl HoldRow {
    /// 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/ledger.read.v1.HoldRow";
}
::buffa::impl_default_instance!(HoldRow);
impl ::buffa::MessageName for HoldRow {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "HoldRow";
    const FULL_NAME: &'static str = "ledger.read.v1.HoldRow";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.HoldRow";
}
impl ::buffa::Message for HoldRow {
    /// 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;
        if self.hold_id != 0u64 {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if self.amount_reserved_e18.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.amount_reserved_e18.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.asset_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
        }
        if self.expires_at_ns != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.expires_at_ns) 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 _;
        if self.hold_id != 0u64 {
            ::buffa::types::put_fixed64_field(1u32, self.hold_id, buf);
        }
        if self.amount_reserved_e18.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.amount_reserved_e18.write_to(__cache, buf);
        }
        if self.asset_id != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.asset_id, buf);
        }
        if self.expires_at_ns != 0u64 {
            ::buffa::types::put_uint64_field(4u32, self.expires_at_ns, 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::Fixed64,
                )?;
                self.hold_id = ::buffa::types::decode_fixed64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.amount_reserved_e18.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.asset_id = ::buffa::types::decode_uint32(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.expires_at_ns = ::buffa::types::decode_uint64(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.hold_id = 0u64;
        self.amount_reserved_e18 = ::buffa::MessageField::none();
        self.asset_id = 0u32;
        self.expires_at_ns = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HoldRow {
    const PROTO_FQN: &'static str = "ledger.read.v1.HoldRow";
    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 HoldRow {
    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 __HOLD_ROW_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.HoldRow",
    to_json: ::buffa::type_registry::any_to_json::<HoldRow>,
    from_json: ::buffa::type_registry::any_from_json::<HoldRow>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListHoldsResponse {
    /// Hold rows in the sort direction requested by the caller.
    ///
    /// Field 1: `holds`
    #[serde(
        rename = "holds",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub holds: ::buffa::alloc::vec::Vec<HoldRow>,
    /// Opaque cursor for the next page. Empty when no more results exist.
    ///
    /// Field 2: `next_page_token`
    #[serde(
        rename = "nextPageToken",
        alias = "next_page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub next_page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListHoldsResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListHoldsResponse")
            .field("holds", &self.holds)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl ListHoldsResponse {
    /// 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/ledger.read.v1.ListHoldsResponse";
}
::buffa::impl_default_instance!(ListHoldsResponse);
impl ::buffa::MessageName for ListHoldsResponse {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "ListHoldsResponse";
    const FULL_NAME: &'static str = "ledger.read.v1.ListHoldsResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListHoldsResponse";
}
impl ::buffa::Message for ListHoldsResponse {
    /// 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;
        for v in &self.holds {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if !self.next_page_token.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.next_page_token) 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 _;
        for v in &self.holds {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if !self.next_page_token.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.next_page_token, 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::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.holds.push(elem);
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.next_page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.holds.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListHoldsResponse {
    const PROTO_FQN: &'static str = "ledger.read.v1.ListHoldsResponse";
    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 ListHoldsResponse {
    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 __LIST_HOLDS_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.ListHoldsResponse",
    to_json: ::buffa::type_registry::any_to_json::<ListHoldsResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ListHoldsResponse>,
    is_wkt: false,
};
/// ErrorDetail is attached to ConnectRPC errors for structured error handling.
/// Clients can inspect this to get a stable machine-readable error code.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ErrorDetail {
    /// Stable error code matching the REST problem+json "code" field.
    ///
    /// Field 1: `code`
    #[serde(
        rename = "code",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub code: ::buffa::EnumValue<ErrorCode>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ErrorDetail {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ErrorDetail").field("code", &self.code).finish()
    }
}
impl ErrorDetail {
    /// 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/ledger.read.v1.ErrorDetail";
}
::buffa::impl_default_instance!(ErrorDetail);
impl ::buffa::MessageName for ErrorDetail {
    const PACKAGE: &'static str = "ledger.read.v1";
    const NAME: &'static str = "ErrorDetail";
    const FULL_NAME: &'static str = "ledger.read.v1.ErrorDetail";
    const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ErrorDetail";
}
impl ::buffa::Message for ErrorDetail {
    /// 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.code.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.code.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, 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.code = ::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.code = ::buffa::EnumValue::from(0);
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ErrorDetail {
    const PROTO_FQN: &'static str = "ledger.read.v1.ErrorDetail";
    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 ErrorDetail {
    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 __ERROR_DETAIL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/ledger.read.v1.ErrorDetail",
    to_json: ::buffa::type_registry::any_to_json::<ErrorDetail>,
    from_json: ::buffa::type_registry::any_from_json::<ErrorDetail>,
    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::*;
        /// Read surface for the Ledger (stable, versionable).
        ///
        /// Canonical amounts are represented as integer quantities:
        /// - IDs: fixed64/uint32
        /// - Ledger amounts: U128 (hi/lo) at fixed 18-decimal scale
        /// - Chart series: scaled integer vectors (e.g. *_q) with field-specific scales
        ///
        /// REST JSON responses render
        /// human-friendly decimal strings without duplicating REST message types here.
        #[derive(Clone, Debug, Default)]
        pub struct GetBalancesRequestView<'a> {
            /// Optional sub-account to scope balances to. If omitted, balances are
            /// returned for the authenticated root account derived from the JWT or API
            /// key. The logical account id itself is always derived from the caller's JWT
            /// or API key, not from this payload.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: ::core::option::Option<u64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetBalancesRequestView<'a> {
            type Owned = super::super::GetBalancesRequest;
            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::Fixed64,
                        )?;
                        view.subaccount_id = Some(
                            ::buffa::types::decode_fixed64(&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::GetBalancesRequest,
                ::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::GetBalancesRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetBalancesRequest {
                    subaccount_id: self.subaccount_id,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetBalancesRequestView<'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;
                if self.subaccount_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN 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 _;
                if let Some(v) = self.subaccount_id {
                    ::buffa::types::put_fixed64_field(1u32, v, 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 GetBalancesRequestView<'__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 let ::core::option::Option::Some(__v) = self.subaccount_id {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetBalancesRequestView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetBalancesRequest";
            const FULL_NAME: &'static str = "ledger.read.v1.GetBalancesRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalancesRequest";
        }
        ::buffa::impl_default_view_instance!(GetBalancesRequestView);
        ::buffa::impl_view_reborrow!(GetBalancesRequestView);
        /** Self-contained, `'static` owned view of a `GetBalancesRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetBalancesRequestView`]`<'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 [`GetBalancesRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetBalancesRequestOwnedView(
            ::buffa::OwnedView<GetBalancesRequestView<'static>>,
        );
        impl GetBalancesRequestOwnedView {
            /// 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(
                    GetBalancesRequestOwnedView(::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(
                    GetBalancesRequestOwnedView(
                        ::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::GetBalancesRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetBalancesRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetBalancesRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetBalancesRequestView<'_> {
                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::GetBalancesRequest,
                ::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()
            }
            /// Optional sub-account to scope balances to. If omitted, balances are
            /// returned for the authenticated root account derived from the JWT or API
            /// key. The logical account id itself is always derived from the caller's JWT
            /// or API key, not from this payload.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().subaccount_id
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetBalancesRequestView<'static>>>
        for GetBalancesRequestOwnedView {
            fn from(inner: ::buffa::OwnedView<GetBalancesRequestView<'static>>) -> Self {
                GetBalancesRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetBalancesRequestOwnedView>
        for ::buffa::OwnedView<GetBalancesRequestView<'static>> {
            fn from(wrapper: GetBalancesRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetBalancesRequestView<'static>>>
        for GetBalancesRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetBalancesRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetBalancesRequest {
            type View<'a> = GetBalancesRequestView<'a>;
            type ViewHandle = GetBalancesRequestOwnedView;
        }
        impl ::serde::Serialize for GetBalancesRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Fixed-size representation for balances (for Protobuf/WS clients).
        /// Uses common U128 messages for amounts to keep schema tidy and consistent.
        #[derive(Clone, Debug, Default)]
        pub struct AssetBalanceView<'a> {
            /// Public unified asset id. Resolve symbol from SpotConfig; U128 amounts in
            /// this message always use fixed 18-decimal ledger scale.
            ///
            /// Field 1: `asset_id`
            pub asset_id: u32,
            /// Trading balance at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `trading`
            pub trading: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Funding balance at fixed 18-decimal ledger scale.
            ///
            /// Field 3: `funding`
            pub funding: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Reserved amount in the trading bucket at fixed 18-decimal ledger scale.
            ///
            /// Field 4: `reserved`
            pub reserved: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Amount currently available for new trading activity at fixed 18-decimal
            /// ledger scale. This value already accounts for active reservations.
            ///
            /// Field 5: `available`
            pub available: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Opaque monotonic revision for the atomic trading, reserved, and available
            /// values. Higher means newer; zero means no trading state has been observed.
            ///
            /// Field 6: `trading_revision`
            pub trading_revision: u64,
            /// Opaque monotonic revision for the funding value. Higher means newer; zero
            /// means no funding state has been observed.
            ///
            /// Field 7: `funding_revision`
            pub funding_revision: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for AssetBalanceView<'a> {
            type Owned = super::super::AssetBalance;
            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.asset_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.trading.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.trading = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.funding.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.funding = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.reserved.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.reserved = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.available.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.available = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.trading_revision = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.funding_revision = ::buffa::types::decode_uint64(&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::AssetBalance,
                ::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::AssetBalance,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::AssetBalance {
                    asset_id: self.asset_id,
                    trading: match self.trading.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    funding: match self.funding.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    reserved: match self.reserved.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    available: match self.available.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    trading_revision: self.trading_revision,
                    funding_revision: self.funding_revision,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for AssetBalanceView<'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;
                if self.asset_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
                }
                if self.trading.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.trading.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.funding.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.funding.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.reserved.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.reserved.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.available.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.available.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.trading_revision != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.trading_revision)
                                as u32;
                }
                if self.funding_revision != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.funding_revision)
                                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 _;
                if self.asset_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
                }
                if self.trading.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.trading.write_to(__cache, buf);
                }
                if self.funding.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.funding.write_to(__cache, buf);
                }
                if self.reserved.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.reserved.write_to(__cache, buf);
                }
                if self.available.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.available.write_to(__cache, buf);
                }
                if self.trading_revision != 0u64 {
                    ::buffa::types::put_uint64_field(6u32, self.trading_revision, buf);
                }
                if self.funding_revision != 0u64 {
                    ::buffa::types::put_uint64_field(7u32, self.funding_revision, 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 AssetBalanceView<'__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_zero_u32(&self.asset_id) {
                    __map
                        .serialize_entry(
                            "assetId",
                            &::buffa::json_helpers::ProtoJson(&self.asset_id),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.trading.as_option() {
                        __map.serialize_entry("trading", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.funding.as_option() {
                        __map.serialize_entry("funding", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.reserved.as_option()
                    {
                        __map.serialize_entry("reserved", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.available.as_option()
                    {
                        __map.serialize_entry("available", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.trading_revision) {
                    __map
                        .serialize_entry(
                            "tradingRevision",
                            &::buffa::json_helpers::ProtoJson(&self.trading_revision),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.funding_revision) {
                    __map
                        .serialize_entry(
                            "fundingRevision",
                            &::buffa::json_helpers::ProtoJson(&self.funding_revision),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for AssetBalanceView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "AssetBalance";
            const FULL_NAME: &'static str = "ledger.read.v1.AssetBalance";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AssetBalance";
        }
        ::buffa::impl_default_view_instance!(AssetBalanceView);
        ::buffa::impl_view_reborrow!(AssetBalanceView);
        /** Self-contained, `'static` owned view of a `AssetBalance` message.

 Wraps [`::buffa::OwnedView`]`<`[`AssetBalanceView`]`<'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 [`AssetBalanceView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct AssetBalanceOwnedView(::buffa::OwnedView<AssetBalanceView<'static>>);
        impl AssetBalanceOwnedView {
            /// 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(
                    AssetBalanceOwnedView(::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(
                    AssetBalanceOwnedView(
                        ::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::AssetBalance,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    AssetBalanceOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`AssetBalanceView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &AssetBalanceView<'_> {
                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::AssetBalance,
                ::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()
            }
            /// Public unified asset id. Resolve symbol from SpotConfig; U128 amounts in
            /// this message always use fixed 18-decimal ledger scale.
            ///
            /// Field 1: `asset_id`
            #[must_use]
            pub fn asset_id(&self) -> u32 {
                self.0.reborrow().asset_id
            }
            /// Trading balance at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `trading`
            #[must_use]
            pub fn trading(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().trading
            }
            /// Funding balance at fixed 18-decimal ledger scale.
            ///
            /// Field 3: `funding`
            #[must_use]
            pub fn funding(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().funding
            }
            /// Reserved amount in the trading bucket at fixed 18-decimal ledger scale.
            ///
            /// Field 4: `reserved`
            #[must_use]
            pub fn reserved(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().reserved
            }
            /// Amount currently available for new trading activity at fixed 18-decimal
            /// ledger scale. This value already accounts for active reservations.
            ///
            /// Field 5: `available`
            #[must_use]
            pub fn available(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().available
            }
            /// Opaque monotonic revision for the atomic trading, reserved, and available
            /// values. Higher means newer; zero means no trading state has been observed.
            ///
            /// Field 6: `trading_revision`
            #[must_use]
            pub fn trading_revision(&self) -> u64 {
                self.0.reborrow().trading_revision
            }
            /// Opaque monotonic revision for the funding value. Higher means newer; zero
            /// means no funding state has been observed.
            ///
            /// Field 7: `funding_revision`
            #[must_use]
            pub fn funding_revision(&self) -> u64 {
                self.0.reborrow().funding_revision
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<AssetBalanceView<'static>>>
        for AssetBalanceOwnedView {
            fn from(inner: ::buffa::OwnedView<AssetBalanceView<'static>>) -> Self {
                AssetBalanceOwnedView(inner)
            }
        }
        impl ::core::convert::From<AssetBalanceOwnedView>
        for ::buffa::OwnedView<AssetBalanceView<'static>> {
            fn from(wrapper: AssetBalanceOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<AssetBalanceView<'static>>>
        for AssetBalanceOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<AssetBalanceView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::AssetBalance {
            type View<'a> = AssetBalanceView<'a>;
            type ViewHandle = AssetBalanceOwnedView;
        }
        impl ::serde::Serialize for AssetBalanceOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        #[derive(Clone, Debug, Default)]
        pub struct GetBalancesResponseView<'a> {
            /// One entry for every supported unified asset, including assets with zero
            /// balances. Sorted by available trading amount (highest first), then by
            /// asset symbol alphabetically.
            ///
            /// Field 1: `balances`
            pub balances: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::AssetBalanceView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetBalancesResponseView<'a> {
            type Owned = super::super::GetBalancesResponse;
            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::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.balances
                            .push(
                                <super::super::__buffa::view::AssetBalanceView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    _ => {
                        ::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::GetBalancesResponse,
                ::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::GetBalancesResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetBalancesResponse {
                    balances: self
                        .balances
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetBalancesResponseView<'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;
                for v in &self.balances {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                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 _;
                for v in &self.balances {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, 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 GetBalancesResponseView<'__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 !self.balances.is_empty() {
                    __map.serialize_entry("balances", &*self.balances)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetBalancesResponseView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetBalancesResponse";
            const FULL_NAME: &'static str = "ledger.read.v1.GetBalancesResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalancesResponse";
        }
        ::buffa::impl_default_view_instance!(GetBalancesResponseView);
        ::buffa::impl_view_reborrow!(GetBalancesResponseView);
        /** Self-contained, `'static` owned view of a `GetBalancesResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetBalancesResponseView`]`<'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 [`GetBalancesResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetBalancesResponseOwnedView(
            ::buffa::OwnedView<GetBalancesResponseView<'static>>,
        );
        impl GetBalancesResponseOwnedView {
            /// 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(
                    GetBalancesResponseOwnedView(::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(
                    GetBalancesResponseOwnedView(
                        ::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::GetBalancesResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetBalancesResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetBalancesResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetBalancesResponseView<'_> {
                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::GetBalancesResponse,
                ::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()
            }
            /// One entry for every supported unified asset, including assets with zero
            /// balances. Sorted by available trading amount (highest first), then by
            /// asset symbol alphabetically.
            ///
            /// Field 1: `balances`
            #[must_use]
            pub fn balances(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::AssetBalanceView<'_>,
            > {
                &self.0.reborrow().balances
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetBalancesResponseView<'static>>>
        for GetBalancesResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetBalancesResponseView<'static>>,
            ) -> Self {
                GetBalancesResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetBalancesResponseOwnedView>
        for ::buffa::OwnedView<GetBalancesResponseView<'static>> {
            fn from(wrapper: GetBalancesResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetBalancesResponseView<'static>>>
        for GetBalancesResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetBalancesResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetBalancesResponse {
            type View<'a> = GetBalancesResponseView<'a>;
            type ViewHandle = GetBalancesResponseOwnedView;
        }
        impl ::serde::Serialize for GetBalancesResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        #[derive(Clone, Debug, Default)]
        pub struct GetBalanceHistoryRequestView<'a> {
            /// Optional sub-account to scope balances to. If omitted, balances are
            /// returned for the authenticated root account derived from the JWT or API
            /// key. The logical account id itself is always derived from the caller's JWT
            /// or API key, not from this payload.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: ::core::option::Option<u64>,
            /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
            ///
            /// Field 2: `range`
            pub range: ::buffa::EnumValue<super::super::BalanceRange>,
            /// Optional public asset filter. When unset/0, returns all assets.
            ///
            /// Field 3: `ledger`
            pub ledger: u32,
            /// Optional subset of account buckets to return. When empty, returns all
            /// account buckets.
            ///
            /// Field 4: `account_codes`
            pub account_codes: ::buffa::RepeatedView<
                'a,
                ::buffa::EnumValue<super::super::super::super::v1::AccountCode>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetBalanceHistoryRequestView<'a> {
            type Owned = super::super::GetBalanceHistoryRequest;
            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::Fixed64,
                        )?;
                        view.subaccount_id = Some(
                            ::buffa::types::decode_fixed64(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.range = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ledger = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    4u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.account_codes
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.account_codes
                                    .push(
                                        ::buffa::EnumValue::from(
                                            ::buffa::types::decode_int32(&mut pcur)?,
                                        ),
                                    );
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.account_codes
                                .push(
                                    ::buffa::EnumValue::from(
                                        ::buffa::types::decode_int32(&mut cur)?,
                                    ),
                                );
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    _ => {
                        ::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::GetBalanceHistoryRequest,
                ::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::GetBalanceHistoryRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetBalanceHistoryRequest {
                    subaccount_id: self.subaccount_id,
                    range: self.range,
                    ledger: self.ledger,
                    account_codes: self.account_codes.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetBalanceHistoryRequestView<'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;
                if self.subaccount_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                {
                    let val = self.range.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.ledger != 0u32 {
                    size
                        += 1u32 + ::buffa::types::uint32_encoded_len(self.ledger) as u32;
                }
                if !self.account_codes.is_empty() {
                    let payload: u32 = self
                        .account_codes
                        .iter()
                        .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                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 _;
                if let Some(v) = self.subaccount_id {
                    ::buffa::types::put_fixed64_field(1u32, v, buf);
                }
                {
                    let val = self.range.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if self.ledger != 0u32 {
                    ::buffa::types::put_uint32_field(3u32, self.ledger, buf);
                }
                if !self.account_codes.is_empty() {
                    let payload: u32 = self
                        .account_codes
                        .iter()
                        .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(4u32, payload, buf);
                    for v in &self.account_codes {
                        ::buffa::types::encode_int32(v.to_i32(), 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 GetBalanceHistoryRequestView<'__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 let ::core::option::Option::Some(__v) = self.subaccount_id {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.range) {
                    __map.serialize_entry("range", &self.range)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.ledger) {
                    __map
                        .serialize_entry(
                            "ledger",
                            &::buffa::json_helpers::ProtoJson(&self.ledger),
                        )?;
                }
                if !self.account_codes.is_empty() {
                    __map
                        .serialize_entry(
                            "accountCodes",
                            &::buffa::json_helpers::EnumSeqJson(&self.account_codes),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetBalanceHistoryRequestView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetBalanceHistoryRequest";
            const FULL_NAME: &'static str = "ledger.read.v1.GetBalanceHistoryRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalanceHistoryRequest";
        }
        ::buffa::impl_default_view_instance!(GetBalanceHistoryRequestView);
        ::buffa::impl_view_reborrow!(GetBalanceHistoryRequestView);
        /** Self-contained, `'static` owned view of a `GetBalanceHistoryRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetBalanceHistoryRequestView`]`<'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 [`GetBalanceHistoryRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetBalanceHistoryRequestOwnedView(
            ::buffa::OwnedView<GetBalanceHistoryRequestView<'static>>,
        );
        impl GetBalanceHistoryRequestOwnedView {
            /// 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(
                    GetBalanceHistoryRequestOwnedView(::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(
                    GetBalanceHistoryRequestOwnedView(
                        ::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::GetBalanceHistoryRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetBalanceHistoryRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetBalanceHistoryRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetBalanceHistoryRequestView<'_> {
                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::GetBalanceHistoryRequest,
                ::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()
            }
            /// Optional sub-account to scope balances to. If omitted, balances are
            /// returned for the authenticated root account derived from the JWT or API
            /// key. The logical account id itself is always derived from the caller's JWT
            /// or API key, not from this payload.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().subaccount_id
            }
            /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
            ///
            /// Field 2: `range`
            #[must_use]
            pub fn range(&self) -> ::buffa::EnumValue<super::super::BalanceRange> {
                self.0.reborrow().range
            }
            /// Optional public asset filter. When unset/0, returns all assets.
            ///
            /// Field 3: `ledger`
            #[must_use]
            pub fn ledger(&self) -> u32 {
                self.0.reborrow().ledger
            }
            /// Optional subset of account buckets to return. When empty, returns all
            /// account buckets.
            ///
            /// Field 4: `account_codes`
            #[must_use]
            pub fn account_codes(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                ::buffa::EnumValue<super::super::super::super::v1::AccountCode>,
            > {
                &self.0.reborrow().account_codes
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetBalanceHistoryRequestView<'static>>,
        > for GetBalanceHistoryRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetBalanceHistoryRequestView<'static>>,
            ) -> Self {
                GetBalanceHistoryRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetBalanceHistoryRequestOwnedView>
        for ::buffa::OwnedView<GetBalanceHistoryRequestView<'static>> {
            fn from(wrapper: GetBalanceHistoryRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetBalanceHistoryRequestView<'static>>,
        > for GetBalanceHistoryRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetBalanceHistoryRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetBalanceHistoryRequest {
            type View<'a> = GetBalanceHistoryRequestView<'a>;
            type ViewHandle = GetBalanceHistoryRequestOwnedView;
        }
        impl ::serde::Serialize for GetBalanceHistoryRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Columnar balance series payload (scaled integers).
        /// REST renders decimal strings from these values.
        #[derive(Clone, Debug, Default)]
        pub struct BalanceSeriesView<'a> {
            /// public unified asset id
            ///
            /// Field 1: `asset_id`
            pub asset_id: u32,
            /// account bucket
            ///
            /// Field 2: `account_code`
            pub account_code: ::buffa::EnumValue<
                super::super::super::super::v1::AccountCode,
            >,
            /// Chart balance in asset units scaled by 1e7 (7 decimals).
            /// Values are downscaled from 18-decimal ledger balances for compact charting
            /// and align 1:1 with implicit timestamps.
            ///
            /// Field 3: `balance_q`
            pub balance_q: ::buffa::RepeatedView<'a, u64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for BalanceSeriesView<'a> {
            type Owned = super::super::BalanceSeries;
            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.asset_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.account_code = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.balance_q
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.balance_q
                                    .push(::buffa::types::decode_uint64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.balance_q
                                .push(::buffa::types::decode_uint64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    _ => {
                        ::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::BalanceSeries,
                ::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::BalanceSeries,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::BalanceSeries {
                    asset_id: self.asset_id,
                    account_code: self.account_code,
                    balance_q: self.balance_q.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for BalanceSeriesView<'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;
                if self.asset_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
                }
                {
                    let val = self.account_code.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.balance_q.is_empty() {
                    let payload: u32 = self
                        .balance_q
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                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 _;
                if self.asset_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
                }
                {
                    let val = self.account_code.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if !self.balance_q.is_empty() {
                    let payload: u32 = self
                        .balance_q
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(3u32, payload, buf);
                    for &v in &self.balance_q {
                        ::buffa::types::encode_uint64(v, 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 BalanceSeriesView<'__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_zero_u32(&self.asset_id) {
                    __map
                        .serialize_entry(
                            "assetId",
                            &::buffa::json_helpers::ProtoJson(&self.asset_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.account_code,
                ) {
                    __map.serialize_entry("accountCode", &self.account_code)?;
                }
                if !self.balance_q.is_empty() {
                    __map
                        .serialize_entry(
                            "balanceQ",
                            &::buffa::json_helpers::RepeatedJson(&self.balance_q),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for BalanceSeriesView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "BalanceSeries";
            const FULL_NAME: &'static str = "ledger.read.v1.BalanceSeries";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.BalanceSeries";
        }
        ::buffa::impl_default_view_instance!(BalanceSeriesView);
        ::buffa::impl_view_reborrow!(BalanceSeriesView);
        /** Self-contained, `'static` owned view of a `BalanceSeries` message.

 Wraps [`::buffa::OwnedView`]`<`[`BalanceSeriesView`]`<'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 [`BalanceSeriesView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct BalanceSeriesOwnedView(
            ::buffa::OwnedView<BalanceSeriesView<'static>>,
        );
        impl BalanceSeriesOwnedView {
            /// 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(
                    BalanceSeriesOwnedView(::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(
                    BalanceSeriesOwnedView(
                        ::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::BalanceSeries,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    BalanceSeriesOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`BalanceSeriesView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &BalanceSeriesView<'_> {
                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::BalanceSeries,
                ::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()
            }
            /// public unified asset id
            ///
            /// Field 1: `asset_id`
            #[must_use]
            pub fn asset_id(&self) -> u32 {
                self.0.reborrow().asset_id
            }
            /// account bucket
            ///
            /// Field 2: `account_code`
            #[must_use]
            pub fn account_code(
                &self,
            ) -> ::buffa::EnumValue<super::super::super::super::v1::AccountCode> {
                self.0.reborrow().account_code
            }
            /// Chart balance in asset units scaled by 1e7 (7 decimals).
            /// Values are downscaled from 18-decimal ledger balances for compact charting
            /// and align 1:1 with implicit timestamps.
            ///
            /// Field 3: `balance_q`
            #[must_use]
            pub fn balance_q(&self) -> &::buffa::RepeatedView<'_, u64> {
                &self.0.reborrow().balance_q
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<BalanceSeriesView<'static>>>
        for BalanceSeriesOwnedView {
            fn from(inner: ::buffa::OwnedView<BalanceSeriesView<'static>>) -> Self {
                BalanceSeriesOwnedView(inner)
            }
        }
        impl ::core::convert::From<BalanceSeriesOwnedView>
        for ::buffa::OwnedView<BalanceSeriesView<'static>> {
            fn from(wrapper: BalanceSeriesOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<BalanceSeriesView<'static>>>
        for BalanceSeriesOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<BalanceSeriesView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::BalanceSeries {
            type View<'a> = BalanceSeriesView<'a>;
            type ViewHandle = BalanceSeriesOwnedView;
        }
        impl ::serde::Serialize for BalanceSeriesOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetBalanceHistoryResponse returns aligned balance chart series.
        #[derive(Clone, Debug, Default)]
        pub struct GetBalanceHistoryResponseView<'a> {
            /// Resolved history window.
            ///
            /// Field 1: `range`
            pub range: ::buffa::EnumValue<super::super::BalanceRange>,
            /// Sampling interval between points, such as "5m" or "1h".
            ///
            /// Field 2: `bucket`
            pub bucket: &'a str,
            /// First point timestamp in seconds since epoch (UTC).
            ///
            /// Field 3: `start_ts_sec`
            pub start_ts_sec: u32,
            /// Last point timestamp in seconds since epoch (UTC).
            ///
            /// Field 4: `end_ts_sec`
            pub end_ts_sec: u32,
            /// Number of aligned points in each returned series.
            ///
            /// Field 5: `points`
            pub points: u32,
            /// Balance series ordered by asset ID, then account bucket.
            ///
            /// Field 6: `series`
            pub series: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::BalanceSeriesView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetBalanceHistoryResponseView<'a> {
            type Owned = super::super::GetBalanceHistoryResponse;
            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.range = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.bucket = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed32,
                        )?;
                        view.start_ts_sec = ::buffa::types::decode_fixed32(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed32,
                        )?;
                        view.end_ts_sec = ::buffa::types::decode_fixed32(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.points = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.series
                            .push(
                                <super::super::__buffa::view::BalanceSeriesView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    _ => {
                        ::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::GetBalanceHistoryResponse,
                ::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::GetBalanceHistoryResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetBalanceHistoryResponse {
                    range: self.range,
                    bucket: self.bucket.to_string(),
                    start_ts_sec: self.start_ts_sec,
                    end_ts_sec: self.end_ts_sec,
                    points: self.points,
                    series: self
                        .series
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetBalanceHistoryResponseView<'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.range.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.bucket.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.bucket) as u32;
                }
                if self.start_ts_sec != 0u32 {
                    size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
                }
                if self.end_ts_sec != 0u32 {
                    size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
                }
                if self.points != 0u32 {
                    size
                        += 1u32 + ::buffa::types::uint32_encoded_len(self.points) as u32;
                }
                for v in &self.series {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                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.range.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, val, buf);
                    }
                }
                if !self.bucket.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.bucket, buf);
                }
                if self.start_ts_sec != 0u32 {
                    ::buffa::types::put_fixed32_field(3u32, self.start_ts_sec, buf);
                }
                if self.end_ts_sec != 0u32 {
                    ::buffa::types::put_fixed32_field(4u32, self.end_ts_sec, buf);
                }
                if self.points != 0u32 {
                    ::buffa::types::put_uint32_field(5u32, self.points, buf);
                }
                for v in &self.series {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, 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 GetBalanceHistoryResponseView<'__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.range) {
                    __map.serialize_entry("range", &self.range)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.bucket) {
                    __map.serialize_entry("bucket", self.bucket)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.start_ts_sec) {
                    __map
                        .serialize_entry(
                            "startTsSec",
                            &::buffa::json_helpers::ProtoJson(&self.start_ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.end_ts_sec) {
                    __map
                        .serialize_entry(
                            "endTsSec",
                            &::buffa::json_helpers::ProtoJson(&self.end_ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.points) {
                    __map
                        .serialize_entry(
                            "points",
                            &::buffa::json_helpers::ProtoJson(&self.points),
                        )?;
                }
                if !self.series.is_empty() {
                    __map.serialize_entry("series", &*self.series)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetBalanceHistoryResponseView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetBalanceHistoryResponse";
            const FULL_NAME: &'static str = "ledger.read.v1.GetBalanceHistoryResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetBalanceHistoryResponse";
        }
        ::buffa::impl_default_view_instance!(GetBalanceHistoryResponseView);
        ::buffa::impl_view_reborrow!(GetBalanceHistoryResponseView);
        /** Self-contained, `'static` owned view of a `GetBalanceHistoryResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetBalanceHistoryResponseView`]`<'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 [`GetBalanceHistoryResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetBalanceHistoryResponseOwnedView(
            ::buffa::OwnedView<GetBalanceHistoryResponseView<'static>>,
        );
        impl GetBalanceHistoryResponseOwnedView {
            /// 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(
                    GetBalanceHistoryResponseOwnedView(
                        ::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(
                    GetBalanceHistoryResponseOwnedView(
                        ::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::GetBalanceHistoryResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetBalanceHistoryResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetBalanceHistoryResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetBalanceHistoryResponseView<'_> {
                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::GetBalanceHistoryResponse,
                ::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()
            }
            /// Resolved history window.
            ///
            /// Field 1: `range`
            #[must_use]
            pub fn range(&self) -> ::buffa::EnumValue<super::super::BalanceRange> {
                self.0.reborrow().range
            }
            /// Sampling interval between points, such as "5m" or "1h".
            ///
            /// Field 2: `bucket`
            #[must_use]
            pub fn bucket(&self) -> &'_ str {
                self.0.reborrow().bucket
            }
            /// First point timestamp in seconds since epoch (UTC).
            ///
            /// Field 3: `start_ts_sec`
            #[must_use]
            pub fn start_ts_sec(&self) -> u32 {
                self.0.reborrow().start_ts_sec
            }
            /// Last point timestamp in seconds since epoch (UTC).
            ///
            /// Field 4: `end_ts_sec`
            #[must_use]
            pub fn end_ts_sec(&self) -> u32 {
                self.0.reborrow().end_ts_sec
            }
            /// Number of aligned points in each returned series.
            ///
            /// Field 5: `points`
            #[must_use]
            pub fn points(&self) -> u32 {
                self.0.reborrow().points
            }
            /// Balance series ordered by asset ID, then account bucket.
            ///
            /// Field 6: `series`
            #[must_use]
            pub fn series(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::BalanceSeriesView<'_>,
            > {
                &self.0.reborrow().series
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetBalanceHistoryResponseView<'static>>,
        > for GetBalanceHistoryResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetBalanceHistoryResponseView<'static>>,
            ) -> Self {
                GetBalanceHistoryResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetBalanceHistoryResponseOwnedView>
        for ::buffa::OwnedView<GetBalanceHistoryResponseView<'static>> {
            fn from(wrapper: GetBalanceHistoryResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetBalanceHistoryResponseView<'static>>,
        > for GetBalanceHistoryResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetBalanceHistoryResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetBalanceHistoryResponse {
            type View<'a> = GetBalanceHistoryResponseView<'a>;
            type ViewHandle = GetBalanceHistoryResponseOwnedView;
        }
        impl ::serde::Serialize for GetBalanceHistoryResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Account grouping metadata (used when group_by = ACCOUNT).
        #[derive(Clone, Debug, Default)]
        pub struct AccountGroupingView<'a> {
            /// account bucket code
            ///
            /// Field 1: `account_code`
            pub account_code: u32,
            /// human-readable name ("funding", "trading")
            ///
            /// Field 2: `name`
            pub name: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for AccountGroupingView<'a> {
            type Owned = super::super::AccountGrouping;
            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.account_code = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.name = ::buffa::types::borrow_str(&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::AccountGrouping,
                ::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::AccountGrouping,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::AccountGrouping {
                    account_code: self.account_code,
                    name: self.name.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for AccountGroupingView<'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;
                if self.account_code != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.account_code)
                                as u32;
                }
                if !self.name.is_empty() {
                    size += 1u32 + ::buffa::types::string_encoded_len(&self.name) 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 _;
                if self.account_code != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.account_code, buf);
                }
                if !self.name.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.name, 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 AccountGroupingView<'__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_zero_u32(&self.account_code) {
                    __map
                        .serialize_entry(
                            "accountCode",
                            &::buffa::json_helpers::ProtoJson(&self.account_code),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
                    __map.serialize_entry("name", self.name)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for AccountGroupingView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "AccountGrouping";
            const FULL_NAME: &'static str = "ledger.read.v1.AccountGrouping";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AccountGrouping";
        }
        ::buffa::impl_default_view_instance!(AccountGroupingView);
        ::buffa::impl_view_reborrow!(AccountGroupingView);
        /** Self-contained, `'static` owned view of a `AccountGrouping` message.

 Wraps [`::buffa::OwnedView`]`<`[`AccountGroupingView`]`<'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 [`AccountGroupingView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct AccountGroupingOwnedView(
            ::buffa::OwnedView<AccountGroupingView<'static>>,
        );
        impl AccountGroupingOwnedView {
            /// 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(
                    AccountGroupingOwnedView(::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(
                    AccountGroupingOwnedView(
                        ::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::AccountGrouping,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    AccountGroupingOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`AccountGroupingView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &AccountGroupingView<'_> {
                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::AccountGrouping,
                ::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()
            }
            /// account bucket code
            ///
            /// Field 1: `account_code`
            #[must_use]
            pub fn account_code(&self) -> u32 {
                self.0.reborrow().account_code
            }
            /// human-readable name ("funding", "trading")
            ///
            /// Field 2: `name`
            #[must_use]
            pub fn name(&self) -> &'_ str {
                self.0.reborrow().name
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<AccountGroupingView<'static>>>
        for AccountGroupingOwnedView {
            fn from(inner: ::buffa::OwnedView<AccountGroupingView<'static>>) -> Self {
                AccountGroupingOwnedView(inner)
            }
        }
        impl ::core::convert::From<AccountGroupingOwnedView>
        for ::buffa::OwnedView<AccountGroupingView<'static>> {
            fn from(wrapper: AccountGroupingOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<AccountGroupingView<'static>>>
        for AccountGroupingOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<AccountGroupingView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::AccountGrouping {
            type View<'a> = AccountGroupingView<'a>;
            type ViewHandle = AccountGroupingOwnedView;
        }
        impl ::serde::Serialize for AccountGroupingOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Asset grouping metadata (used when group_by = ASSET).
        #[derive(Clone, Debug, Default)]
        pub struct AssetGroupingView<'a> {
            /// public asset id (0 for "OTHER" bucket)
            ///
            /// Field 1: `id`
            pub id: u32,
            /// asset symbol ("BTC", "ETH", "OTHER")
            ///
            /// Field 2: `symbol`
            pub symbol: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for AssetGroupingView<'a> {
            type Owned = super::super::AssetGrouping;
            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.id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.symbol = ::buffa::types::borrow_str(&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::AssetGrouping,
                ::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::AssetGrouping,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::AssetGrouping {
                    id: self.id,
                    symbol: self.symbol.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for AssetGroupingView<'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;
                if self.id != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.id) as u32;
                }
                if !self.symbol.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.symbol) 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 _;
                if self.id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.id, buf);
                }
                if !self.symbol.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.symbol, 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 AssetGroupingView<'__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_zero_u32(&self.id) {
                    __map
                        .serialize_entry(
                            "id",
                            &::buffa::json_helpers::ProtoJson(&self.id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.symbol) {
                    __map.serialize_entry("symbol", self.symbol)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for AssetGroupingView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "AssetGrouping";
            const FULL_NAME: &'static str = "ledger.read.v1.AssetGrouping";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.AssetGrouping";
        }
        ::buffa::impl_default_view_instance!(AssetGroupingView);
        ::buffa::impl_view_reborrow!(AssetGroupingView);
        /** Self-contained, `'static` owned view of a `AssetGrouping` message.

 Wraps [`::buffa::OwnedView`]`<`[`AssetGroupingView`]`<'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 [`AssetGroupingView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct AssetGroupingOwnedView(
            ::buffa::OwnedView<AssetGroupingView<'static>>,
        );
        impl AssetGroupingOwnedView {
            /// 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(
                    AssetGroupingOwnedView(::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(
                    AssetGroupingOwnedView(
                        ::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::AssetGrouping,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    AssetGroupingOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`AssetGroupingView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &AssetGroupingView<'_> {
                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::AssetGrouping,
                ::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()
            }
            /// public asset id (0 for "OTHER" bucket)
            ///
            /// Field 1: `id`
            #[must_use]
            pub fn id(&self) -> u32 {
                self.0.reborrow().id
            }
            /// asset symbol ("BTC", "ETH", "OTHER")
            ///
            /// Field 2: `symbol`
            #[must_use]
            pub fn symbol(&self) -> &'_ str {
                self.0.reborrow().symbol
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<AssetGroupingView<'static>>>
        for AssetGroupingOwnedView {
            fn from(inner: ::buffa::OwnedView<AssetGroupingView<'static>>) -> Self {
                AssetGroupingOwnedView(inner)
            }
        }
        impl ::core::convert::From<AssetGroupingOwnedView>
        for ::buffa::OwnedView<AssetGroupingView<'static>> {
            fn from(wrapper: AssetGroupingOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<AssetGroupingView<'static>>>
        for AssetGroupingOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<AssetGroupingView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::AssetGrouping {
            type View<'a> = AssetGroupingView<'a>;
            type ViewHandle = AssetGroupingOwnedView;
        }
        impl ::serde::Serialize for AssetGroupingOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Equity history in USDT (or BTC via client-side conversion using btc_prices).
        /// Values are derived from per-asset balances and market prices (close ticks).
        #[derive(Clone, Debug, Default)]
        pub struct GetEquityHistorySeriesRequestView<'a> {
            /// Optional sub-account to scope equity to. If omitted, equity is returned for
            /// the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: ::core::option::Option<u64>,
            /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
            ///
            /// Field 2: `range`
            pub range: ::buffa::EnumValue<super::super::BalanceRange>,
            /// Optional subset of account buckets.
            /// When empty, server returns both funding and trading.
            /// Only used when group_by = ACCOUNT.
            ///
            /// Field 4: `account_codes`
            pub account_codes: ::buffa::RepeatedView<
                'a,
                ::buffa::EnumValue<super::super::super::super::v1::AccountCode>,
            >,
            /// How to group the equity series. Defaults to ACCOUNT if unspecified.
            ///
            /// Field 5: `group_by`
            pub group_by: ::buffa::EnumValue<super::super::EquityGroupBy>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetEquityHistorySeriesRequestView<'a> {
            type Owned = super::super::GetEquityHistorySeriesRequest;
            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::Fixed64,
                        )?;
                        view.subaccount_id = Some(
                            ::buffa::types::decode_fixed64(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.range = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.group_by = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    4u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.account_codes
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.account_codes
                                    .push(
                                        ::buffa::EnumValue::from(
                                            ::buffa::types::decode_int32(&mut pcur)?,
                                        ),
                                    );
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.account_codes
                                .push(
                                    ::buffa::EnumValue::from(
                                        ::buffa::types::decode_int32(&mut cur)?,
                                    ),
                                );
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    _ => {
                        ::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::GetEquityHistorySeriesRequest,
                ::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::GetEquityHistorySeriesRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetEquityHistorySeriesRequest {
                    subaccount_id: self.subaccount_id,
                    range: self.range,
                    account_codes: self.account_codes.to_vec(),
                    group_by: self.group_by,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetEquityHistorySeriesRequestView<'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;
                if self.subaccount_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                {
                    let val = self.range.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.account_codes.is_empty() {
                    let payload: u32 = self
                        .account_codes
                        .iter()
                        .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                {
                    let val = self.group_by.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 _;
                if let Some(v) = self.subaccount_id {
                    ::buffa::types::put_fixed64_field(1u32, v, buf);
                }
                {
                    let val = self.range.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if !self.account_codes.is_empty() {
                    let payload: u32 = self
                        .account_codes
                        .iter()
                        .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(4u32, payload, buf);
                    for v in &self.account_codes {
                        ::buffa::types::encode_int32(v.to_i32(), buf);
                    }
                }
                {
                    let val = self.group_by.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(5u32, 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 GetEquityHistorySeriesRequestView<'__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 let ::core::option::Option::Some(__v) = self.subaccount_id {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.range) {
                    __map.serialize_entry("range", &self.range)?;
                }
                if !self.account_codes.is_empty() {
                    __map
                        .serialize_entry(
                            "accountCodes",
                            &::buffa::json_helpers::EnumSeqJson(&self.account_codes),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.group_by,
                ) {
                    __map.serialize_entry("groupBy", &self.group_by)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetEquityHistorySeriesRequestView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetEquityHistorySeriesRequest";
            const FULL_NAME: &'static str = "ledger.read.v1.GetEquityHistorySeriesRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesRequest";
        }
        ::buffa::impl_default_view_instance!(GetEquityHistorySeriesRequestView);
        ::buffa::impl_view_reborrow!(GetEquityHistorySeriesRequestView);
        /** Self-contained, `'static` owned view of a `GetEquityHistorySeriesRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetEquityHistorySeriesRequestView`]`<'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 [`GetEquityHistorySeriesRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetEquityHistorySeriesRequestOwnedView(
            ::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>>,
        );
        impl GetEquityHistorySeriesRequestOwnedView {
            /// 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(
                    GetEquityHistorySeriesRequestOwnedView(
                        ::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(
                    GetEquityHistorySeriesRequestOwnedView(
                        ::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::GetEquityHistorySeriesRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetEquityHistorySeriesRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetEquityHistorySeriesRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetEquityHistorySeriesRequestView<'_> {
                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::GetEquityHistorySeriesRequest,
                ::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()
            }
            /// Optional sub-account to scope equity to. If omitted, equity is returned for
            /// the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().subaccount_id
            }
            /// History window to return. When unset/UNSPECIFIED, defaults to 1D.
            ///
            /// Field 2: `range`
            #[must_use]
            pub fn range(&self) -> ::buffa::EnumValue<super::super::BalanceRange> {
                self.0.reborrow().range
            }
            /// Optional subset of account buckets.
            /// When empty, server returns both funding and trading.
            /// Only used when group_by = ACCOUNT.
            ///
            /// Field 4: `account_codes`
            #[must_use]
            pub fn account_codes(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                ::buffa::EnumValue<super::super::super::super::v1::AccountCode>,
            > {
                &self.0.reborrow().account_codes
            }
            /// How to group the equity series. Defaults to ACCOUNT if unspecified.
            ///
            /// Field 5: `group_by`
            #[must_use]
            pub fn group_by(&self) -> ::buffa::EnumValue<super::super::EquityGroupBy> {
                self.0.reborrow().group_by
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>>,
        > for GetEquityHistorySeriesRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>>,
            ) -> Self {
                GetEquityHistorySeriesRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetEquityHistorySeriesRequestOwnedView>
        for ::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>> {
            fn from(wrapper: GetEquityHistorySeriesRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>>,
        > for GetEquityHistorySeriesRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetEquityHistorySeriesRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetEquityHistorySeriesRequest {
            type View<'a> = GetEquityHistorySeriesRequestView<'a>;
            type ViewHandle = GetEquityHistorySeriesRequestOwnedView;
        }
        impl ::serde::Serialize for GetEquityHistorySeriesRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Columnar equity series payload (scaled integers).
        /// REST renders decimal strings from these values.
        #[derive(Clone, Debug, Default)]
        pub struct EquitySeriesView<'a> {
            /// Equity in quote currency (USDT) scaled by 1e4 (4 decimals).
            /// Values align 1:1 with timestamps.
            ///
            /// Field 2: `equity_q`
            pub equity_q: ::buffa::RepeatedView<'a, i64>,
            pub grouping: ::core::option::Option<
                super::super::__buffa::view::oneof::equity_series::Grouping<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for EquitySeriesView<'a> {
            type Owned = super::super::EquitySeries;
            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() {
                    2u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.equity_q
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.equity_q
                                    .push(::buffa::types::decode_sint64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.equity_q.push(::buffa::types::decode_sint64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        if let Some(
                            super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                                ref mut existing,
                            ),
                        ) = view.grouping
                        {
                            ::buffa::MessageView::merge_into_view(
                                &mut **existing,
                                sub,
                                __sub_ctx,
                            )?;
                        } else {
                            view.grouping = Some(
                                super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                                    ::buffa::alloc::boxed::Box::new(
                                        <super::super::__buffa::view::AccountGroupingView as ::buffa::MessageView>::decode_view_ctx(
                                            sub,
                                            __sub_ctx,
                                        )?,
                                    ),
                                ),
                            );
                        }
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        if let Some(
                            super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                                ref mut existing,
                            ),
                        ) = view.grouping
                        {
                            ::buffa::MessageView::merge_into_view(
                                &mut **existing,
                                sub,
                                __sub_ctx,
                            )?;
                        } else {
                            view.grouping = Some(
                                super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                                    ::buffa::alloc::boxed::Box::new(
                                        <super::super::__buffa::view::AssetGroupingView as ::buffa::MessageView>::decode_view_ctx(
                                            sub,
                                            __sub_ctx,
                                        )?,
                                    ),
                                ),
                            );
                        }
                    }
                    _ => {
                        ::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::EquitySeries,
                ::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::EquitySeries,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::EquitySeries {
                    equity_q: self.equity_q.to_vec(),
                    grouping: match self.grouping.as_ref() {
                        ::core::option::Option::Some(v) => {
                            ::core::option::Option::Some(
                                match v {
                                    super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                                        v,
                                    ) => {
                                        super::super::__buffa::oneof::equity_series::Grouping::Account(
                                            ::buffa::alloc::boxed::Box::new(
                                                v.to_owned_from_source(__buffa_src)?,
                                            ),
                                        )
                                    }
                                    super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                                        v,
                                    ) => {
                                        super::super::__buffa::oneof::equity_series::Grouping::Asset(
                                            ::buffa::alloc::boxed::Box::new(
                                                v.to_owned_from_source(__buffa_src)?,
                                            ),
                                        )
                                    }
                                },
                            )
                        }
                        ::core::option::Option::None => ::core::option::Option::None,
                    },
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for EquitySeriesView<'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;
                if let ::core::option::Option::Some(ref v) = self.grouping {
                    match v {
                        super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                            x,
                        ) => {
                            let __slot = __cache.reserve();
                            let inner = x.compute_size(__cache);
                            __cache.set(__slot, inner);
                            size
                                += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                                    + inner;
                        }
                        super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                            x,
                        ) => {
                            let __slot = __cache.reserve();
                            let inner = x.compute_size(__cache);
                            __cache.set(__slot, inner);
                            size
                                += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                                    + inner;
                        }
                    }
                }
                if !self.equity_q.is_empty() {
                    let payload: u32 = self
                        .equity_q
                        .iter()
                        .map(|&v| ::buffa::types::sint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                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 _;
                if let ::core::option::Option::Some(ref v) = self.grouping {
                    match v {
                        super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                            x,
                        ) => {
                            ::buffa::types::put_len_delimited_header(
                                1u32,
                                __cache.consume_next(),
                                buf,
                            );
                            x.write_to(__cache, buf);
                        }
                        super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                            x,
                        ) => {
                            ::buffa::types::put_len_delimited_header(
                                3u32,
                                __cache.consume_next(),
                                buf,
                            );
                            x.write_to(__cache, buf);
                        }
                    }
                }
                if !self.equity_q.is_empty() {
                    let payload: u32 = self
                        .equity_q
                        .iter()
                        .map(|&v| ::buffa::types::sint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(2u32, payload, buf);
                    for &v in &self.equity_q {
                        ::buffa::types::encode_sint64(v, 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 EquitySeriesView<'__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 !self.equity_q.is_empty() {
                    __map
                        .serialize_entry(
                            "equityQ",
                            &::buffa::json_helpers::RepeatedJson(&self.equity_q),
                        )?;
                }
                if let ::core::option::Option::Some(ref __ov) = self.grouping {
                    match __ov {
                        super::super::__buffa::view::oneof::equity_series::Grouping::Account(
                            v,
                        ) => {
                            __map.serialize_entry("account", v)?;
                        }
                        super::super::__buffa::view::oneof::equity_series::Grouping::Asset(
                            v,
                        ) => {
                            __map.serialize_entry("asset", v)?;
                        }
                    }
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for EquitySeriesView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "EquitySeries";
            const FULL_NAME: &'static str = "ledger.read.v1.EquitySeries";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.EquitySeries";
        }
        ::buffa::impl_default_view_instance!(EquitySeriesView);
        ::buffa::impl_view_reborrow!(EquitySeriesView);
        /** Self-contained, `'static` owned view of a `EquitySeries` message.

 Wraps [`::buffa::OwnedView`]`<`[`EquitySeriesView`]`<'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 [`EquitySeriesView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct EquitySeriesOwnedView(::buffa::OwnedView<EquitySeriesView<'static>>);
        impl EquitySeriesOwnedView {
            /// 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(
                    EquitySeriesOwnedView(::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(
                    EquitySeriesOwnedView(
                        ::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::EquitySeries,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    EquitySeriesOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`EquitySeriesView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &EquitySeriesView<'_> {
                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::EquitySeries,
                ::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()
            }
            /// Equity in quote currency (USDT) scaled by 1e4 (4 decimals).
            /// Values align 1:1 with timestamps.
            ///
            /// Field 2: `equity_q`
            #[must_use]
            pub fn equity_q(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().equity_q
            }
            /// Oneof `grouping`.
            #[must_use]
            pub fn grouping(
                &self,
            ) -> ::core::option::Option<
                &super::super::__buffa::view::oneof::equity_series::Grouping<'_>,
            > {
                self.0.reborrow().grouping.as_ref()
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<EquitySeriesView<'static>>>
        for EquitySeriesOwnedView {
            fn from(inner: ::buffa::OwnedView<EquitySeriesView<'static>>) -> Self {
                EquitySeriesOwnedView(inner)
            }
        }
        impl ::core::convert::From<EquitySeriesOwnedView>
        for ::buffa::OwnedView<EquitySeriesView<'static>> {
            fn from(wrapper: EquitySeriesOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<EquitySeriesView<'static>>>
        for EquitySeriesOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<EquitySeriesView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::EquitySeries {
            type View<'a> = EquitySeriesView<'a>;
            type ViewHandle = EquitySeriesOwnedView;
        }
        impl ::serde::Serialize for EquitySeriesOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetEquityHistorySeriesResponse returns aligned equity chart series.
        #[derive(Clone, Debug, Default)]
        pub struct GetEquityHistorySeriesResponseView<'a> {
            /// Resolved history window.
            ///
            /// Field 1: `range`
            pub range: ::buffa::EnumValue<super::super::BalanceRange>,
            /// Sampling interval between points, such as "5m" or "1h".
            ///
            /// Field 2: `bucket`
            pub bucket: &'a str,
            /// First point timestamp in seconds since epoch (UTC).
            ///
            /// Field 3: `start_ts_sec`
            pub start_ts_sec: u32,
            /// Last point timestamp in seconds since epoch (UTC).
            ///
            /// Field 4: `end_ts_sec`
            pub end_ts_sec: u32,
            /// Human-readable quote asset symbol (always "USDT").
            ///
            /// Field 6: `quote_asset`
            pub quote_asset: &'a str,
            /// Number of aligned points in each returned series.
            ///
            /// Field 7: `points`
            pub points: u32,
            /// Equity series ordered by grouping identifier ascending.
            ///
            /// Field 8: `series`
            pub series: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::EquitySeriesView<'a>,
            >,
            /// BTC-USDT close price at each timestamp, scaled by 1e6 (same as price_ticks).
            /// Enables client-side conversion to BTC denomination without refetch.
            ///
            /// Field 10: `btc_prices_q`
            pub btc_prices_q: ::buffa::RepeatedView<'a, i64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetEquityHistorySeriesResponseView<'a> {
            type Owned = super::super::GetEquityHistorySeriesResponse;
            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.range = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.bucket = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed32,
                        )?;
                        view.start_ts_sec = ::buffa::types::decode_fixed32(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed32,
                        )?;
                        view.end_ts_sec = ::buffa::types::decode_fixed32(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.quote_asset = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.points = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.series
                            .push(
                                <super::super::__buffa::view::EquitySeriesView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    10u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.btc_prices_q
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.btc_prices_q
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.btc_prices_q
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    _ => {
                        ::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::GetEquityHistorySeriesResponse,
                ::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::GetEquityHistorySeriesResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetEquityHistorySeriesResponse {
                    range: self.range,
                    bucket: self.bucket.to_string(),
                    start_ts_sec: self.start_ts_sec,
                    end_ts_sec: self.end_ts_sec,
                    quote_asset: self.quote_asset.to_string(),
                    points: self.points,
                    series: self
                        .series
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    btc_prices_q: self.btc_prices_q.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetEquityHistorySeriesResponseView<'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.range.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.bucket.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.bucket) as u32;
                }
                if self.start_ts_sec != 0u32 {
                    size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
                }
                if self.end_ts_sec != 0u32 {
                    size += 1u32 + ::buffa::types::FIXED32_ENCODED_LEN as u32;
                }
                if !self.quote_asset.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.quote_asset)
                                as u32;
                }
                if self.points != 0u32 {
                    size
                        += 1u32 + ::buffa::types::uint32_encoded_len(self.points) as u32;
                }
                for v in &self.series {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if !self.btc_prices_q.is_empty() {
                    let payload: u32 = self
                        .btc_prices_q
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                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.range.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, val, buf);
                    }
                }
                if !self.bucket.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.bucket, buf);
                }
                if self.start_ts_sec != 0u32 {
                    ::buffa::types::put_fixed32_field(3u32, self.start_ts_sec, buf);
                }
                if self.end_ts_sec != 0u32 {
                    ::buffa::types::put_fixed32_field(4u32, self.end_ts_sec, buf);
                }
                if !self.quote_asset.is_empty() {
                    ::buffa::types::put_string_field(6u32, &self.quote_asset, buf);
                }
                if self.points != 0u32 {
                    ::buffa::types::put_uint32_field(7u32, self.points, buf);
                }
                for v in &self.series {
                    ::buffa::types::put_len_delimited_header(
                        8u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if !self.btc_prices_q.is_empty() {
                    let payload: u32 = self
                        .btc_prices_q
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(10u32, payload, buf);
                    for &v in &self.btc_prices_q {
                        ::buffa::types::encode_int64(v, 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 GetEquityHistorySeriesResponseView<'__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.range) {
                    __map.serialize_entry("range", &self.range)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.bucket) {
                    __map.serialize_entry("bucket", self.bucket)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.start_ts_sec) {
                    __map
                        .serialize_entry(
                            "startTsSec",
                            &::buffa::json_helpers::ProtoJson(&self.start_ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.end_ts_sec) {
                    __map
                        .serialize_entry(
                            "endTsSec",
                            &::buffa::json_helpers::ProtoJson(&self.end_ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.quote_asset) {
                    __map.serialize_entry("quoteAsset", self.quote_asset)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.points) {
                    __map
                        .serialize_entry(
                            "points",
                            &::buffa::json_helpers::ProtoJson(&self.points),
                        )?;
                }
                if !self.series.is_empty() {
                    __map.serialize_entry("series", &*self.series)?;
                }
                if !self.btc_prices_q.is_empty() {
                    __map
                        .serialize_entry(
                            "btcPricesQ",
                            &::buffa::json_helpers::RepeatedJson(&self.btc_prices_q),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetEquityHistorySeriesResponseView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "GetEquityHistorySeriesResponse";
            const FULL_NAME: &'static str = "ledger.read.v1.GetEquityHistorySeriesResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.GetEquityHistorySeriesResponse";
        }
        ::buffa::impl_default_view_instance!(GetEquityHistorySeriesResponseView);
        ::buffa::impl_view_reborrow!(GetEquityHistorySeriesResponseView);
        /** Self-contained, `'static` owned view of a `GetEquityHistorySeriesResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetEquityHistorySeriesResponseView`]`<'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 [`GetEquityHistorySeriesResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetEquityHistorySeriesResponseOwnedView(
            ::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>>,
        );
        impl GetEquityHistorySeriesResponseOwnedView {
            /// 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(
                    GetEquityHistorySeriesResponseOwnedView(
                        ::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(
                    GetEquityHistorySeriesResponseOwnedView(
                        ::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::GetEquityHistorySeriesResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetEquityHistorySeriesResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetEquityHistorySeriesResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetEquityHistorySeriesResponseView<'_> {
                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::GetEquityHistorySeriesResponse,
                ::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()
            }
            /// Resolved history window.
            ///
            /// Field 1: `range`
            #[must_use]
            pub fn range(&self) -> ::buffa::EnumValue<super::super::BalanceRange> {
                self.0.reborrow().range
            }
            /// Sampling interval between points, such as "5m" or "1h".
            ///
            /// Field 2: `bucket`
            #[must_use]
            pub fn bucket(&self) -> &'_ str {
                self.0.reborrow().bucket
            }
            /// First point timestamp in seconds since epoch (UTC).
            ///
            /// Field 3: `start_ts_sec`
            #[must_use]
            pub fn start_ts_sec(&self) -> u32 {
                self.0.reborrow().start_ts_sec
            }
            /// Last point timestamp in seconds since epoch (UTC).
            ///
            /// Field 4: `end_ts_sec`
            #[must_use]
            pub fn end_ts_sec(&self) -> u32 {
                self.0.reborrow().end_ts_sec
            }
            /// Human-readable quote asset symbol (always "USDT").
            ///
            /// Field 6: `quote_asset`
            #[must_use]
            pub fn quote_asset(&self) -> &'_ str {
                self.0.reborrow().quote_asset
            }
            /// Number of aligned points in each returned series.
            ///
            /// Field 7: `points`
            #[must_use]
            pub fn points(&self) -> u32 {
                self.0.reborrow().points
            }
            /// Equity series ordered by grouping identifier ascending.
            ///
            /// Field 8: `series`
            #[must_use]
            pub fn series(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::EquitySeriesView<'_>,
            > {
                &self.0.reborrow().series
            }
            /// BTC-USDT close price at each timestamp, scaled by 1e6 (same as price_ticks).
            /// Enables client-side conversion to BTC denomination without refetch.
            ///
            /// Field 10: `btc_prices_q`
            #[must_use]
            pub fn btc_prices_q(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().btc_prices_q
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>>,
        > for GetEquityHistorySeriesResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>>,
            ) -> Self {
                GetEquityHistorySeriesResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetEquityHistorySeriesResponseOwnedView>
        for ::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>> {
            fn from(wrapper: GetEquityHistorySeriesResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>>,
        > for GetEquityHistorySeriesResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetEquityHistorySeriesResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetEquityHistorySeriesResponse {
            type View<'a> = GetEquityHistorySeriesResponseView<'a>;
            type ViewHandle = GetEquityHistorySeriesResponseOwnedView;
        }
        impl ::serde::Serialize for GetEquityHistorySeriesResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        #[derive(Clone, Debug, Default)]
        pub struct ListTransfersRequestView<'a> {
            /// Optional sub-account to scope transfers to. If omitted, transfers are
            /// listed for the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: ::core::option::Option<u64>,
            /// Maximum number of transfer rows to return. Defaults to 100 when omitted;
            /// maximum is 1000.
            ///
            /// Field 2: `limit`
            pub limit: u32,
            /// Sort direction. When true, rows are returned newest first; when false,
            /// rows are returned oldest first.
            ///
            /// Field 3: `reversed`
            pub reversed: bool,
            /// Optional lower transfer timestamp bound in microseconds since epoch (UTC),
            /// inclusive.
            ///
            /// Field 4: `ts_min_us`
            pub ts_min_us: u64,
            /// Optional upper transfer timestamp bound in microseconds since epoch (UTC),
            /// inclusive.
            ///
            /// Field 5: `ts_max_us`
            pub ts_max_us: u64,
            /// Optional filter by transfer reason.
            ///
            /// Field 6: `transfer_code`
            pub transfer_code: ::buffa::EnumValue<
                super::super::super::super::v1::TransferCode,
            >,
            /// Optional filter by asset ledger.
            ///
            /// Field 7: `ledger`
            pub ledger: u32,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to the authenticated account, sub-account scope, filters, timestamp
            /// bounds, and sort direction.
            ///
            /// Field 9: `page_token`
            pub page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListTransfersRequestView<'a> {
            type Owned = super::super::ListTransfersRequest;
            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::Fixed64,
                        )?;
                        view.subaccount_id = Some(
                            ::buffa::types::decode_fixed64(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.reversed = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_min_us = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_max_us = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.transfer_code = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ledger = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&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::ListTransfersRequest,
                ::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::ListTransfersRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListTransfersRequest {
                    subaccount_id: self.subaccount_id,
                    limit: self.limit,
                    reversed: self.reversed,
                    ts_min_us: self.ts_min_us,
                    ts_max_us: self.ts_max_us,
                    transfer_code: self.transfer_code,
                    ledger: self.ledger,
                    page_token: self.page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListTransfersRequestView<'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;
                if self.subaccount_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if self.reversed {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.ts_min_us != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.ts_min_us) as u32;
                }
                if self.ts_max_us != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.ts_max_us) as u32;
                }
                {
                    let val = self.transfer_code.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.ledger != 0u32 {
                    size
                        += 1u32 + ::buffa::types::uint32_encoded_len(self.ledger) as u32;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                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 _;
                if let Some(v) = self.subaccount_id {
                    ::buffa::types::put_fixed64_field(1u32, v, buf);
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.limit, buf);
                }
                if self.reversed {
                    ::buffa::types::put_bool_field(3u32, self.reversed, buf);
                }
                if self.ts_min_us != 0u64 {
                    ::buffa::types::put_uint64_field(4u32, self.ts_min_us, buf);
                }
                if self.ts_max_us != 0u64 {
                    ::buffa::types::put_uint64_field(5u32, self.ts_max_us, buf);
                }
                {
                    let val = self.transfer_code.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(6u32, val, buf);
                    }
                }
                if self.ledger != 0u32 {
                    ::buffa::types::put_uint32_field(7u32, self.ledger, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(9u32, &self.page_token, 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 ListTransfersRequestView<'__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 let ::core::option::Option::Some(__v) = self.subaccount_id {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                if self.reversed {
                    __map.serialize_entry("reversed", &self.reversed)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_min_us) {
                    __map
                        .serialize_entry(
                            "tsMinUs",
                            &::buffa::json_helpers::ProtoJson(&self.ts_min_us),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_max_us) {
                    __map
                        .serialize_entry(
                            "tsMaxUs",
                            &::buffa::json_helpers::ProtoJson(&self.ts_max_us),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.transfer_code,
                ) {
                    __map.serialize_entry("transferCode", &self.transfer_code)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.ledger) {
                    __map
                        .serialize_entry(
                            "ledger",
                            &::buffa::json_helpers::ProtoJson(&self.ledger),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListTransfersRequestView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "ListTransfersRequest";
            const FULL_NAME: &'static str = "ledger.read.v1.ListTransfersRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListTransfersRequest";
        }
        ::buffa::impl_default_view_instance!(ListTransfersRequestView);
        ::buffa::impl_view_reborrow!(ListTransfersRequestView);
        /** Self-contained, `'static` owned view of a `ListTransfersRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListTransfersRequestView`]`<'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 [`ListTransfersRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListTransfersRequestOwnedView(
            ::buffa::OwnedView<ListTransfersRequestView<'static>>,
        );
        impl ListTransfersRequestOwnedView {
            /// 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(
                    ListTransfersRequestOwnedView(::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(
                    ListTransfersRequestOwnedView(
                        ::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::ListTransfersRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListTransfersRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`ListTransfersRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListTransfersRequestView<'_> {
                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::ListTransfersRequest,
                ::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()
            }
            /// Optional sub-account to scope transfers to. If omitted, transfers are
            /// listed for the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().subaccount_id
            }
            /// Maximum number of transfer rows to return. Defaults to 100 when omitted;
            /// maximum is 1000.
            ///
            /// Field 2: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Sort direction. When true, rows are returned newest first; when false,
            /// rows are returned oldest first.
            ///
            /// Field 3: `reversed`
            #[must_use]
            pub fn reversed(&self) -> bool {
                self.0.reborrow().reversed
            }
            /// Optional lower transfer timestamp bound in microseconds since epoch (UTC),
            /// inclusive.
            ///
            /// Field 4: `ts_min_us`
            #[must_use]
            pub fn ts_min_us(&self) -> u64 {
                self.0.reborrow().ts_min_us
            }
            /// Optional upper transfer timestamp bound in microseconds since epoch (UTC),
            /// inclusive.
            ///
            /// Field 5: `ts_max_us`
            #[must_use]
            pub fn ts_max_us(&self) -> u64 {
                self.0.reborrow().ts_max_us
            }
            /// Optional filter by transfer reason.
            ///
            /// Field 6: `transfer_code`
            #[must_use]
            pub fn transfer_code(
                &self,
            ) -> ::buffa::EnumValue<super::super::super::super::v1::TransferCode> {
                self.0.reborrow().transfer_code
            }
            /// Optional filter by asset ledger.
            ///
            /// Field 7: `ledger`
            #[must_use]
            pub fn ledger(&self) -> u32 {
                self.0.reborrow().ledger
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to the authenticated account, sub-account scope, filters, timestamp
            /// bounds, and sort direction.
            ///
            /// Field 9: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<ListTransfersRequestView<'static>>>
        for ListTransfersRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListTransfersRequestView<'static>>,
            ) -> Self {
                ListTransfersRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListTransfersRequestOwnedView>
        for ::buffa::OwnedView<ListTransfersRequestView<'static>> {
            fn from(wrapper: ListTransfersRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListTransfersRequestView<'static>>,
        > for ListTransfersRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<ListTransfersRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListTransfersRequest {
            type View<'a> = ListTransfersRequestView<'a>;
            type ViewHandle = ListTransfersRequestOwnedView;
        }
        impl ::serde::Serialize for ListTransfersRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// TransferSide describes one side of a ledger transfer for display.
        #[derive(Clone, Debug, Default)]
        pub struct TransferSideView<'a> {
            /// Display classification for this transfer side.
            ///
            /// Field 1: `kind`
            pub kind: ::buffa::EnumValue<super::super::TransferSideKind>,
            /// Public root account or subaccount ID when this side is safe to identify. Never
            /// populated for private counterparties or non-user ledger accounts.
            ///
            /// Field 2: `account_id`
            pub account_id: ::core::option::Option<u64>,
            /// Address for this side when known. For EXTERNAL_ADDRESS this is an
            /// external-chain wallet address from lifecycle correlation; for identifiable
            /// Polyester accounts this is a Polyester smart-account address.
            /// May be empty until the corresponding lifecycle details are available.
            ///
            /// Field 3: `address`
            pub address: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for TransferSideView<'a> {
            type Owned = super::super::TransferSide;
            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.kind = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed64,
                        )?;
                        view.account_id = Some(
                            ::buffa::types::decode_fixed64(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.address = ::buffa::types::borrow_str(&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::TransferSide,
                ::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::TransferSide,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::TransferSide {
                    kind: self.kind,
                    account_id: self.account_id,
                    address: self.address.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for TransferSideView<'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.kind.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.account_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if !self.address.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.address) 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.kind.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, val, buf);
                    }
                }
                if let Some(v) = self.account_id {
                    ::buffa::types::put_fixed64_field(2u32, v, buf);
                }
                if !self.address.is_empty() {
                    ::buffa::types::put_string_field(3u32, &self.address, 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 TransferSideView<'__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.kind) {
                    __map.serialize_entry("kind", &self.kind)?;
                }
                if let ::core::option::Option::Some(__v) = self.account_id {
                    __map
                        .serialize_entry(
                            "accountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.address) {
                    __map.serialize_entry("address", self.address)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for TransferSideView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "TransferSide";
            const FULL_NAME: &'static str = "ledger.read.v1.TransferSide";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.TransferSide";
        }
        ::buffa::impl_default_view_instance!(TransferSideView);
        ::buffa::impl_view_reborrow!(TransferSideView);
        /** Self-contained, `'static` owned view of a `TransferSide` message.

 Wraps [`::buffa::OwnedView`]`<`[`TransferSideView`]`<'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 [`TransferSideView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct TransferSideOwnedView(::buffa::OwnedView<TransferSideView<'static>>);
        impl TransferSideOwnedView {
            /// 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(
                    TransferSideOwnedView(::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(
                    TransferSideOwnedView(
                        ::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::TransferSide,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    TransferSideOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`TransferSideView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &TransferSideView<'_> {
                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::TransferSide,
                ::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()
            }
            /// Display classification for this transfer side.
            ///
            /// Field 1: `kind`
            #[must_use]
            pub fn kind(&self) -> ::buffa::EnumValue<super::super::TransferSideKind> {
                self.0.reborrow().kind
            }
            /// Public root account or subaccount ID when this side is safe to identify. Never
            /// populated for private counterparties or non-user ledger accounts.
            ///
            /// Field 2: `account_id`
            #[must_use]
            pub fn account_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().account_id
            }
            /// Address for this side when known. For EXTERNAL_ADDRESS this is an
            /// external-chain wallet address from lifecycle correlation; for identifiable
            /// Polyester accounts this is a Polyester smart-account address.
            /// May be empty until the corresponding lifecycle details are available.
            ///
            /// Field 3: `address`
            #[must_use]
            pub fn address(&self) -> &'_ str {
                self.0.reborrow().address
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<TransferSideView<'static>>>
        for TransferSideOwnedView {
            fn from(inner: ::buffa::OwnedView<TransferSideView<'static>>) -> Self {
                TransferSideOwnedView(inner)
            }
        }
        impl ::core::convert::From<TransferSideOwnedView>
        for ::buffa::OwnedView<TransferSideView<'static>> {
            fn from(wrapper: TransferSideOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<TransferSideView<'static>>>
        for TransferSideOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<TransferSideView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::TransferSide {
            type View<'a> = TransferSideView<'a>;
            type ViewHandle = TransferSideOwnedView;
        }
        impl ::serde::Serialize for TransferSideOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// TransferRow describes one debit or credit leg of a ledger transfer.
        #[derive(Clone, Debug, Default)]
        pub struct TransferRowView<'a> {
            /// Public unified asset ID. Resolve its symbol through the spot configuration
            /// API. U128 amounts in this row always use a fixed 18-decimal ledger scale.
            ///
            /// Field 1: `asset_id`
            pub asset_id: u32,
            /// Transfer amount at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `amount_e18`
            pub amount_e18: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Product reason for this transfer.
            ///
            /// Field 3: `transfer_code`
            pub transfer_code: ::buffa::EnumValue<
                super::super::super::super::v1::TransferCode,
            >,
            /// Account bucket affected by this transfer.
            ///
            /// Field 4: `account_code`
            pub account_code: ::buffa::EnumValue<
                super::super::super::super::v1::AccountCode,
            >,
            /// Transfer timestamp in microseconds since epoch (UTC).
            ///
            /// Field 5: `ts_us`
            pub ts_us: u64,
            /// Post-transfer balance at fixed 18-decimal ledger scale.
            ///
            /// Field 9: `balance_after_e18`
            pub balance_after_e18: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// True when this row is the debit leg; false when it is the credit leg.
            ///
            /// Field 10: `is_debit`
            pub is_debit: bool,
            /// Correlation ID used to group related transfer legs. Zero when unavailable.
            ///
            /// Field 11: `link_id`
            pub link_id: u64,
            /// Public lifecycle flow ID when this transfer belongs to a chain lifecycle flow.
            ///
            /// Field 12: `flow_id`
            pub flow_id: &'a str,
            /// Debit side of the transfer. This relationship is debit-to-credit rather
            /// than row-relative; use is_debit to determine whether this row is the debit leg.
            ///
            /// Field 13: `source`
            pub source: ::buffa::MessageFieldView<
                super::super::__buffa::view::TransferSideView<'a>,
            >,
            /// Credit side of the transfer. This relationship is debit-to-credit rather
            /// than row-relative; use is_debit to determine whether this row is the credit leg.
            ///
            /// Field 14: `destination`
            pub destination: ::buffa::MessageFieldView<
                super::super::__buffa::view::TransferSideView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for TransferRowView<'a> {
            type Owned = super::super::TransferRow;
            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.asset_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.amount_e18.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.amount_e18 = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.transfer_code = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.account_code = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_us = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.balance_after_e18.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.balance_after_e18 = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    10u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.is_debit = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    11u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.link_id = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    12u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.flow_id = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    13u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.source.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.source = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::TransferSideView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    14u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.destination.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.destination = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::TransferSideView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    _ => {
                        ::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::TransferRow,
                ::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::TransferRow,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::TransferRow {
                    asset_id: self.asset_id,
                    amount_e18: match self.amount_e18.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    transfer_code: self.transfer_code,
                    account_code: self.account_code,
                    ts_us: self.ts_us,
                    balance_after_e18: match self.balance_after_e18.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    is_debit: self.is_debit,
                    link_id: self.link_id,
                    flow_id: self.flow_id.to_string(),
                    source: match self.source.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::TransferSide,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    destination: match self.destination.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::TransferSide,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for TransferRowView<'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;
                if self.asset_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
                }
                if self.amount_e18.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.amount_e18.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                {
                    let val = self.transfer_code.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.account_code.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.ts_us != 0u64 {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_us) as u32;
                }
                if self.balance_after_e18.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.balance_after_e18.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.is_debit {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.link_id != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.link_id) as u32;
                }
                if !self.flow_id.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.flow_id) as u32;
                }
                if self.source.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.source.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.destination.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.destination.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                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 _;
                if self.asset_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.asset_id, buf);
                }
                if self.amount_e18.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.amount_e18.write_to(__cache, buf);
                }
                {
                    let val = self.transfer_code.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(3u32, val, buf);
                    }
                }
                {
                    let val = self.account_code.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(4u32, val, buf);
                    }
                }
                if self.ts_us != 0u64 {
                    ::buffa::types::put_uint64_field(5u32, self.ts_us, buf);
                }
                if self.balance_after_e18.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        9u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.balance_after_e18.write_to(__cache, buf);
                }
                if self.is_debit {
                    ::buffa::types::put_bool_field(10u32, self.is_debit, buf);
                }
                if self.link_id != 0u64 {
                    ::buffa::types::put_uint64_field(11u32, self.link_id, buf);
                }
                if !self.flow_id.is_empty() {
                    ::buffa::types::put_string_field(12u32, &self.flow_id, buf);
                }
                if self.source.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        13u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.source.write_to(__cache, buf);
                }
                if self.destination.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        14u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.destination.write_to(__cache, 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 TransferRowView<'__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_zero_u32(&self.asset_id) {
                    __map
                        .serialize_entry(
                            "assetId",
                            &::buffa::json_helpers::ProtoJson(&self.asset_id),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .amount_e18
                        .as_option()
                    {
                        __map.serialize_entry("amountE18", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.transfer_code,
                ) {
                    __map.serialize_entry("transferCode", &self.transfer_code)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.account_code,
                ) {
                    __map.serialize_entry("accountCode", &self.account_code)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_us) {
                    __map
                        .serialize_entry(
                            "tsUs",
                            &::buffa::json_helpers::ProtoJson(&self.ts_us),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .balance_after_e18
                        .as_option()
                    {
                        __map.serialize_entry("balanceAfterE18", __v)?;
                    }
                }
                if self.is_debit {
                    __map.serialize_entry("isDebit", &self.is_debit)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.link_id) {
                    __map
                        .serialize_entry(
                            "linkId",
                            &::buffa::json_helpers::ProtoJson(&self.link_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.flow_id) {
                    __map.serialize_entry("flowId", self.flow_id)?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.source.as_option() {
                        __map.serialize_entry("source", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .destination
                        .as_option()
                    {
                        __map.serialize_entry("destination", __v)?;
                    }
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for TransferRowView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "TransferRow";
            const FULL_NAME: &'static str = "ledger.read.v1.TransferRow";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.TransferRow";
        }
        ::buffa::impl_default_view_instance!(TransferRowView);
        ::buffa::impl_view_reborrow!(TransferRowView);
        /** Self-contained, `'static` owned view of a `TransferRow` message.

 Wraps [`::buffa::OwnedView`]`<`[`TransferRowView`]`<'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 [`TransferRowView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct TransferRowOwnedView(::buffa::OwnedView<TransferRowView<'static>>);
        impl TransferRowOwnedView {
            /// 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(
                    TransferRowOwnedView(::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(
                    TransferRowOwnedView(
                        ::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::TransferRow,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    TransferRowOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`TransferRowView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &TransferRowView<'_> {
                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::TransferRow,
                ::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()
            }
            /// Public unified asset ID. Resolve its symbol through the spot configuration
            /// API. U128 amounts in this row always use a fixed 18-decimal ledger scale.
            ///
            /// Field 1: `asset_id`
            #[must_use]
            pub fn asset_id(&self) -> u32 {
                self.0.reborrow().asset_id
            }
            /// Transfer amount at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `amount_e18`
            #[must_use]
            pub fn amount_e18(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().amount_e18
            }
            /// Product reason for this transfer.
            ///
            /// Field 3: `transfer_code`
            #[must_use]
            pub fn transfer_code(
                &self,
            ) -> ::buffa::EnumValue<super::super::super::super::v1::TransferCode> {
                self.0.reborrow().transfer_code
            }
            /// Account bucket affected by this transfer.
            ///
            /// Field 4: `account_code`
            #[must_use]
            pub fn account_code(
                &self,
            ) -> ::buffa::EnumValue<super::super::super::super::v1::AccountCode> {
                self.0.reborrow().account_code
            }
            /// Transfer timestamp in microseconds since epoch (UTC).
            ///
            /// Field 5: `ts_us`
            #[must_use]
            pub fn ts_us(&self) -> u64 {
                self.0.reborrow().ts_us
            }
            /// Post-transfer balance at fixed 18-decimal ledger scale.
            ///
            /// Field 9: `balance_after_e18`
            #[must_use]
            pub fn balance_after_e18(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().balance_after_e18
            }
            /// True when this row is the debit leg; false when it is the credit leg.
            ///
            /// Field 10: `is_debit`
            #[must_use]
            pub fn is_debit(&self) -> bool {
                self.0.reborrow().is_debit
            }
            /// Correlation ID used to group related transfer legs. Zero when unavailable.
            ///
            /// Field 11: `link_id`
            #[must_use]
            pub fn link_id(&self) -> u64 {
                self.0.reborrow().link_id
            }
            /// Public lifecycle flow ID when this transfer belongs to a chain lifecycle flow.
            ///
            /// Field 12: `flow_id`
            #[must_use]
            pub fn flow_id(&self) -> &'_ str {
                self.0.reborrow().flow_id
            }
            /// Debit side of the transfer. This relationship is debit-to-credit rather
            /// than row-relative; use is_debit to determine whether this row is the debit leg.
            ///
            /// Field 13: `source`
            #[must_use]
            pub fn source(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::TransferSideView<'_>,
            > {
                &self.0.reborrow().source
            }
            /// Credit side of the transfer. This relationship is debit-to-credit rather
            /// than row-relative; use is_debit to determine whether this row is the credit leg.
            ///
            /// Field 14: `destination`
            #[must_use]
            pub fn destination(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::TransferSideView<'_>,
            > {
                &self.0.reborrow().destination
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<TransferRowView<'static>>>
        for TransferRowOwnedView {
            fn from(inner: ::buffa::OwnedView<TransferRowView<'static>>) -> Self {
                TransferRowOwnedView(inner)
            }
        }
        impl ::core::convert::From<TransferRowOwnedView>
        for ::buffa::OwnedView<TransferRowView<'static>> {
            fn from(wrapper: TransferRowOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<TransferRowView<'static>>>
        for TransferRowOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<TransferRowView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::TransferRow {
            type View<'a> = TransferRowView<'a>;
            type ViewHandle = TransferRowOwnedView;
        }
        impl ::serde::Serialize for TransferRowOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ListTransfersResponse contains transfer rows and an optional continuation cursor.
        #[derive(Clone, Debug, Default)]
        pub struct ListTransfersResponseView<'a> {
            /// Transfer rows in requested order.
            ///
            /// Field 1: `transfers`
            pub transfers: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::TransferRowView<'a>,
            >,
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 3: `next_page_token`
            pub next_page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListTransfersResponseView<'a> {
            type Owned = super::super::ListTransfersResponse;
            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() {
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.next_page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.transfers
                            .push(
                                <super::super::__buffa::view::TransferRowView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    _ => {
                        ::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::ListTransfersResponse,
                ::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::ListTransfersResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListTransfersResponse {
                    transfers: self
                        .transfers
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    next_page_token: self.next_page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListTransfersResponseView<'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;
                for v in &self.transfers {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if !self.next_page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.next_page_token)
                                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 _;
                for v in &self.transfers {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if !self.next_page_token.is_empty() {
                    ::buffa::types::put_string_field(3u32, &self.next_page_token, 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 ListTransfersResponseView<'__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 !self.transfers.is_empty() {
                    __map.serialize_entry("transfers", &*self.transfers)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.next_page_token) {
                    __map.serialize_entry("nextPageToken", self.next_page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListTransfersResponseView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "ListTransfersResponse";
            const FULL_NAME: &'static str = "ledger.read.v1.ListTransfersResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListTransfersResponse";
        }
        ::buffa::impl_default_view_instance!(ListTransfersResponseView);
        ::buffa::impl_view_reborrow!(ListTransfersResponseView);
        /** Self-contained, `'static` owned view of a `ListTransfersResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListTransfersResponseView`]`<'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 [`ListTransfersResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListTransfersResponseOwnedView(
            ::buffa::OwnedView<ListTransfersResponseView<'static>>,
        );
        impl ListTransfersResponseOwnedView {
            /// 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(
                    ListTransfersResponseOwnedView(::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(
                    ListTransfersResponseOwnedView(
                        ::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::ListTransfersResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListTransfersResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`ListTransfersResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListTransfersResponseView<'_> {
                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::ListTransfersResponse,
                ::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()
            }
            /// Transfer rows in requested order.
            ///
            /// Field 1: `transfers`
            #[must_use]
            pub fn transfers(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::TransferRowView<'_>,
            > {
                &self.0.reborrow().transfers
            }
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 3: `next_page_token`
            #[must_use]
            pub fn next_page_token(&self) -> &'_ str {
                self.0.reborrow().next_page_token
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<ListTransfersResponseView<'static>>,
        > for ListTransfersResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListTransfersResponseView<'static>>,
            ) -> Self {
                ListTransfersResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListTransfersResponseOwnedView>
        for ::buffa::OwnedView<ListTransfersResponseView<'static>> {
            fn from(wrapper: ListTransfersResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListTransfersResponseView<'static>>,
        > for ListTransfersResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<ListTransfersResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListTransfersResponse {
            type View<'a> = ListTransfersResponseView<'a>;
            type ViewHandle = ListTransfersResponseOwnedView;
        }
        impl ::serde::Serialize for ListTransfersResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        #[derive(Clone, Debug, Default)]
        pub struct ListHoldsRequestView<'a> {
            /// Optional sub-account to scope holds to. If omitted, holds are listed for
            /// the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: ::core::option::Option<u64>,
            /// Maximum number of holds to return. Defaults to 100 when omitted; maximum is
            /// 1000.
            ///
            /// Field 2: `limit`
            pub limit: u32,
            /// true=newest first; false=oldest first.
            ///
            /// Field 3: `reversed`
            pub reversed: bool,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to account, sub-account scope, and sort direction.
            ///
            /// Field 4: `page_token`
            pub page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListHoldsRequestView<'a> {
            type Owned = super::super::ListHoldsRequest;
            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::Fixed64,
                        )?;
                        view.subaccount_id = Some(
                            ::buffa::types::decode_fixed64(&mut cur)?,
                        );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.reversed = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&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::ListHoldsRequest,
                ::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::ListHoldsRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListHoldsRequest {
                    subaccount_id: self.subaccount_id,
                    limit: self.limit,
                    reversed: self.reversed,
                    page_token: self.page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListHoldsRequestView<'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;
                if self.subaccount_id.is_some() {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if self.reversed {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                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 _;
                if let Some(v) = self.subaccount_id {
                    ::buffa::types::put_fixed64_field(1u32, v, buf);
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.limit, buf);
                }
                if self.reversed {
                    ::buffa::types::put_bool_field(3u32, self.reversed, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(4u32, &self.page_token, 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 ListHoldsRequestView<'__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 let ::core::option::Option::Some(__v) = self.subaccount_id {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&__v),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                if self.reversed {
                    __map.serialize_entry("reversed", &self.reversed)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListHoldsRequestView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "ListHoldsRequest";
            const FULL_NAME: &'static str = "ledger.read.v1.ListHoldsRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListHoldsRequest";
        }
        ::buffa::impl_default_view_instance!(ListHoldsRequestView);
        ::buffa::impl_view_reborrow!(ListHoldsRequestView);
        /** Self-contained, `'static` owned view of a `ListHoldsRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListHoldsRequestView`]`<'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 [`ListHoldsRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListHoldsRequestOwnedView(
            ::buffa::OwnedView<ListHoldsRequestView<'static>>,
        );
        impl ListHoldsRequestOwnedView {
            /// 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(
                    ListHoldsRequestOwnedView(::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(
                    ListHoldsRequestOwnedView(
                        ::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::ListHoldsRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListHoldsRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`ListHoldsRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListHoldsRequestView<'_> {
                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::ListHoldsRequest,
                ::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()
            }
            /// Optional sub-account to scope holds to. If omitted, holds are listed for
            /// the authenticated root account derived from the JWT or API key.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> ::core::option::Option<u64> {
                self.0.reborrow().subaccount_id
            }
            /// Maximum number of holds to return. Defaults to 100 when omitted; maximum is
            /// 1000.
            ///
            /// Field 2: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// true=newest first; false=oldest first.
            ///
            /// Field 3: `reversed`
            #[must_use]
            pub fn reversed(&self) -> bool {
                self.0.reborrow().reversed
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to account, sub-account scope, and sort direction.
            ///
            /// Field 4: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<ListHoldsRequestView<'static>>>
        for ListHoldsRequestOwnedView {
            fn from(inner: ::buffa::OwnedView<ListHoldsRequestView<'static>>) -> Self {
                ListHoldsRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListHoldsRequestOwnedView>
        for ::buffa::OwnedView<ListHoldsRequestView<'static>> {
            fn from(wrapper: ListHoldsRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<ListHoldsRequestView<'static>>>
        for ListHoldsRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<ListHoldsRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListHoldsRequest {
            type View<'a> = ListHoldsRequestView<'a>;
            type ViewHandle = ListHoldsRequestOwnedView;
        }
        impl ::serde::Serialize for ListHoldsRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Hold row with compact integers and client-side resolution.
        #[derive(Clone, Debug, Default)]
        pub struct HoldRowView<'a> {
            /// pending transfer id (numeric)
            ///
            /// Field 1: `hold_id`
            pub hold_id: u64,
            /// Reserved amount at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `amount_reserved_e18`
            pub amount_reserved_e18: ::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    'a,
                >,
            >,
            /// Public unified asset id.
            ///
            /// Field 3: `asset_id`
            pub asset_id: u32,
            /// Expiration time in nanoseconds since epoch (UTC).
            ///
            /// Field 4: `expires_at_ns`
            pub expires_at_ns: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HoldRowView<'a> {
            type Owned = super::super::HoldRow;
            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::Fixed64,
                        )?;
                        view.hold_id = ::buffa::types::decode_fixed64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.amount_reserved_e18.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.amount_reserved_e18 = ::buffa::MessageFieldView::set(
                                    <super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.asset_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.expires_at_ns = ::buffa::types::decode_uint64(&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::HoldRow, ::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::HoldRow, ::buffa::DecodeError> {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HoldRow {
                    hold_id: self.hold_id,
                    amount_reserved_e18: match self.amount_reserved_e18.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::super::super::super::polyester::r#type::v1::U128,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    asset_id: self.asset_id,
                    expires_at_ns: self.expires_at_ns,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HoldRowView<'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;
                if self.hold_id != 0u64 {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if self.amount_reserved_e18.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.amount_reserved_e18.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.asset_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.asset_id) as u32;
                }
                if self.expires_at_ns != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.expires_at_ns)
                                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 _;
                if self.hold_id != 0u64 {
                    ::buffa::types::put_fixed64_field(1u32, self.hold_id, buf);
                }
                if self.amount_reserved_e18.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.amount_reserved_e18.write_to(__cache, buf);
                }
                if self.asset_id != 0u32 {
                    ::buffa::types::put_uint32_field(3u32, self.asset_id, buf);
                }
                if self.expires_at_ns != 0u64 {
                    ::buffa::types::put_uint64_field(4u32, self.expires_at_ns, 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 HoldRowView<'__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_zero_u64(&self.hold_id) {
                    __map
                        .serialize_entry(
                            "holdId",
                            &::buffa::json_helpers::ProtoJson(&self.hold_id),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .amount_reserved_e18
                        .as_option()
                    {
                        __map.serialize_entry("amountReservedE18", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.asset_id) {
                    __map
                        .serialize_entry(
                            "assetId",
                            &::buffa::json_helpers::ProtoJson(&self.asset_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.expires_at_ns) {
                    __map
                        .serialize_entry(
                            "expiresAtNs",
                            &::buffa::json_helpers::ProtoJson(&self.expires_at_ns),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HoldRowView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "HoldRow";
            const FULL_NAME: &'static str = "ledger.read.v1.HoldRow";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.HoldRow";
        }
        ::buffa::impl_default_view_instance!(HoldRowView);
        ::buffa::impl_view_reborrow!(HoldRowView);
        /** Self-contained, `'static` owned view of a `HoldRow` message.

 Wraps [`::buffa::OwnedView`]`<`[`HoldRowView`]`<'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 [`HoldRowView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HoldRowOwnedView(::buffa::OwnedView<HoldRowView<'static>>);
        impl HoldRowOwnedView {
            /// 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(
                    HoldRowOwnedView(::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(
                    HoldRowOwnedView(
                        ::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::HoldRow,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HoldRowOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HoldRowView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HoldRowView<'_> {
                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::HoldRow, ::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()
            }
            /// pending transfer id (numeric)
            ///
            /// Field 1: `hold_id`
            #[must_use]
            pub fn hold_id(&self) -> u64 {
                self.0.reborrow().hold_id
            }
            /// Reserved amount at fixed 18-decimal ledger scale.
            ///
            /// Field 2: `amount_reserved_e18`
            #[must_use]
            pub fn amount_reserved_e18(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::super::super::super::polyester::r#type::v1::__buffa::view::U128View<
                    '_,
                >,
            > {
                &self.0.reborrow().amount_reserved_e18
            }
            /// Public unified asset id.
            ///
            /// Field 3: `asset_id`
            #[must_use]
            pub fn asset_id(&self) -> u32 {
                self.0.reborrow().asset_id
            }
            /// Expiration time in nanoseconds since epoch (UTC).
            ///
            /// Field 4: `expires_at_ns`
            #[must_use]
            pub fn expires_at_ns(&self) -> u64 {
                self.0.reborrow().expires_at_ns
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HoldRowView<'static>>>
        for HoldRowOwnedView {
            fn from(inner: ::buffa::OwnedView<HoldRowView<'static>>) -> Self {
                HoldRowOwnedView(inner)
            }
        }
        impl ::core::convert::From<HoldRowOwnedView>
        for ::buffa::OwnedView<HoldRowView<'static>> {
            fn from(wrapper: HoldRowOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HoldRowView<'static>>>
        for HoldRowOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HoldRowView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HoldRow {
            type View<'a> = HoldRowView<'a>;
            type ViewHandle = HoldRowOwnedView;
        }
        impl ::serde::Serialize for HoldRowOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        #[derive(Clone, Debug, Default)]
        pub struct ListHoldsResponseView<'a> {
            /// Hold rows in the sort direction requested by the caller.
            ///
            /// Field 1: `holds`
            pub holds: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::HoldRowView<'a>,
            >,
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 2: `next_page_token`
            pub next_page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListHoldsResponseView<'a> {
            type Owned = super::super::ListHoldsResponse;
            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() {
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.next_page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.holds
                            .push(
                                <super::super::__buffa::view::HoldRowView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    _ => {
                        ::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::ListHoldsResponse,
                ::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::ListHoldsResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListHoldsResponse {
                    holds: self
                        .holds
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    next_page_token: self.next_page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListHoldsResponseView<'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;
                for v in &self.holds {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if !self.next_page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.next_page_token)
                                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 _;
                for v in &self.holds {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if !self.next_page_token.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.next_page_token, 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 ListHoldsResponseView<'__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 !self.holds.is_empty() {
                    __map.serialize_entry("holds", &*self.holds)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.next_page_token) {
                    __map.serialize_entry("nextPageToken", self.next_page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListHoldsResponseView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "ListHoldsResponse";
            const FULL_NAME: &'static str = "ledger.read.v1.ListHoldsResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ListHoldsResponse";
        }
        ::buffa::impl_default_view_instance!(ListHoldsResponseView);
        ::buffa::impl_view_reborrow!(ListHoldsResponseView);
        /** Self-contained, `'static` owned view of a `ListHoldsResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListHoldsResponseView`]`<'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 [`ListHoldsResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListHoldsResponseOwnedView(
            ::buffa::OwnedView<ListHoldsResponseView<'static>>,
        );
        impl ListHoldsResponseOwnedView {
            /// 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(
                    ListHoldsResponseOwnedView(::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(
                    ListHoldsResponseOwnedView(
                        ::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::ListHoldsResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListHoldsResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`ListHoldsResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListHoldsResponseView<'_> {
                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::ListHoldsResponse,
                ::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()
            }
            /// Hold rows in the sort direction requested by the caller.
            ///
            /// Field 1: `holds`
            #[must_use]
            pub fn holds(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::HoldRowView<'_>,
            > {
                &self.0.reborrow().holds
            }
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 2: `next_page_token`
            #[must_use]
            pub fn next_page_token(&self) -> &'_ str {
                self.0.reborrow().next_page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<ListHoldsResponseView<'static>>>
        for ListHoldsResponseOwnedView {
            fn from(inner: ::buffa::OwnedView<ListHoldsResponseView<'static>>) -> Self {
                ListHoldsResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListHoldsResponseOwnedView>
        for ::buffa::OwnedView<ListHoldsResponseView<'static>> {
            fn from(wrapper: ListHoldsResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<ListHoldsResponseView<'static>>>
        for ListHoldsResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<ListHoldsResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListHoldsResponse {
            type View<'a> = ListHoldsResponseView<'a>;
            type ViewHandle = ListHoldsResponseOwnedView;
        }
        impl ::serde::Serialize for ListHoldsResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ErrorDetail is attached to ConnectRPC errors for structured error handling.
        /// Clients can inspect this to get a stable machine-readable error code.
        #[derive(Clone, Debug, Default)]
        pub struct ErrorDetailView<'a> {
            /// Stable error code matching the REST problem+json "code" field.
            ///
            /// Field 1: `code`
            pub code: ::buffa::EnumValue<super::super::ErrorCode>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ErrorDetailView<'a> {
            type Owned = super::super::ErrorDetail;
            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.code = ::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::ErrorDetail,
                ::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::ErrorDetail,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ErrorDetail {
                    code: self.code,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ErrorDetailView<'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.code.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.code.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, 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 ErrorDetailView<'__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.code) {
                    __map.serialize_entry("code", &self.code)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ErrorDetailView<'a> {
            const PACKAGE: &'static str = "ledger.read.v1";
            const NAME: &'static str = "ErrorDetail";
            const FULL_NAME: &'static str = "ledger.read.v1.ErrorDetail";
            const TYPE_URL: &'static str = "type.googleapis.com/ledger.read.v1.ErrorDetail";
        }
        ::buffa::impl_default_view_instance!(ErrorDetailView);
        ::buffa::impl_view_reborrow!(ErrorDetailView);
        /** Self-contained, `'static` owned view of a `ErrorDetail` message.

 Wraps [`::buffa::OwnedView`]`<`[`ErrorDetailView`]`<'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 [`ErrorDetailView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ErrorDetailOwnedView(::buffa::OwnedView<ErrorDetailView<'static>>);
        impl ErrorDetailOwnedView {
            /// 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(
                    ErrorDetailOwnedView(::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(
                    ErrorDetailOwnedView(
                        ::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::ErrorDetail,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ErrorDetailOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`ErrorDetailView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ErrorDetailView<'_> {
                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::ErrorDetail,
                ::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()
            }
            /// Stable error code matching the REST problem+json "code" field.
            ///
            /// Field 1: `code`
            #[must_use]
            pub fn code(&self) -> ::buffa::EnumValue<super::super::ErrorCode> {
                self.0.reborrow().code
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<ErrorDetailView<'static>>>
        for ErrorDetailOwnedView {
            fn from(inner: ::buffa::OwnedView<ErrorDetailView<'static>>) -> Self {
                ErrorDetailOwnedView(inner)
            }
        }
        impl ::core::convert::From<ErrorDetailOwnedView>
        for ::buffa::OwnedView<ErrorDetailView<'static>> {
            fn from(wrapper: ErrorDetailOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<ErrorDetailView<'static>>>
        for ErrorDetailOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<ErrorDetailView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ErrorDetail {
            type View<'a> = ErrorDetailView<'a>;
            type ViewHandle = ErrorDetailOwnedView;
        }
        impl ::serde::Serialize for ErrorDetailOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        pub mod oneof {
            #[allow(unused_imports)]
            use super::*;
            pub mod equity_series {
                #[allow(unused_imports)]
                use super::*;
                #[derive(Clone, Debug)]
                pub enum Grouping<'a> {
                    Account(
                        ::buffa::alloc::boxed::Box<
                            super::super::super::super::__buffa::view::AccountGroupingView<
                                'a,
                            >,
                        >,
                    ),
                    Asset(
                        ::buffa::alloc::boxed::Box<
                            super::super::super::super::__buffa::view::AssetGroupingView<
                                'a,
                            >,
                        >,
                    ),
                }
            }
        }
    }
    pub mod oneof {
        #[allow(unused_imports)]
        use super::*;
        pub mod equity_series {
            #[allow(unused_imports)]
            use super::*;
            /// Grouping identifier: either account or asset, depending on request group_by.
            #[derive(Clone, PartialEq, Debug)]
            pub enum Grouping {
                Account(
                    ::buffa::alloc::boxed::Box<super::super::super::AccountGrouping>,
                ),
                Asset(::buffa::alloc::boxed::Box<super::super::super::AssetGrouping>),
            }
            impl ::buffa::Oneof for Grouping {}
            impl From<super::super::super::AccountGrouping> for Grouping {
                fn from(v: super::super::super::AccountGrouping) -> Self {
                    Self::Account(::buffa::alloc::boxed::Box::new(v))
                }
            }
            impl From<super::super::super::AccountGrouping>
            for ::core::option::Option<Grouping> {
                fn from(v: super::super::super::AccountGrouping) -> Self {
                    Self::Some(Grouping::from(v))
                }
            }
            impl From<super::super::super::AssetGrouping> for Grouping {
                fn from(v: super::super::super::AssetGrouping) -> Self {
                    Self::Asset(::buffa::alloc::boxed::Box::new(v))
                }
            }
            impl From<super::super::super::AssetGrouping>
            for ::core::option::Option<Grouping> {
                fn from(v: super::super::super::AssetGrouping) -> Self {
                    Self::Some(Grouping::from(v))
                }
            }
            impl serde::Serialize for Grouping {
                fn serialize<S: serde::Serializer>(
                    &self,
                    s: S,
                ) -> ::core::result::Result<S::Ok, S::Error> {
                    use serde::ser::SerializeMap;
                    let mut map = s.serialize_map(Some(1))?;
                    match self {
                        Self::Account(v) => {
                            map.serialize_entry("account", v)?;
                        }
                        Self::Asset(v) => {
                            map.serialize_entry("asset", v)?;
                        }
                    }
                    map.end()
                }
            }
        }
    }
    /// 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::__GET_BALANCES_REQUEST_JSON_ANY);
        reg.register_json_any(super::__ASSET_BALANCE_JSON_ANY);
        reg.register_json_any(super::__GET_BALANCES_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__GET_BALANCE_HISTORY_REQUEST_JSON_ANY);
        reg.register_json_any(super::__BALANCE_SERIES_JSON_ANY);
        reg.register_json_any(super::__GET_BALANCE_HISTORY_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__ACCOUNT_GROUPING_JSON_ANY);
        reg.register_json_any(super::__ASSET_GROUPING_JSON_ANY);
        reg.register_json_any(super::__GET_EQUITY_HISTORY_SERIES_REQUEST_JSON_ANY);
        reg.register_json_any(super::__EQUITY_SERIES_JSON_ANY);
        reg.register_json_any(super::__GET_EQUITY_HISTORY_SERIES_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__LIST_TRANSFERS_REQUEST_JSON_ANY);
        reg.register_json_any(super::__TRANSFER_SIDE_JSON_ANY);
        reg.register_json_any(super::__TRANSFER_ROW_JSON_ANY);
        reg.register_json_any(super::__LIST_TRANSFERS_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__LIST_HOLDS_REQUEST_JSON_ANY);
        reg.register_json_any(super::__HOLD_ROW_JSON_ANY);
        reg.register_json_any(super::__LIST_HOLDS_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__ERROR_DETAIL_JSON_ANY);
    }
}
#[doc(inline)]
pub use self::__buffa::view::GetBalancesRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetBalancesRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::AssetBalanceView;
#[doc(inline)]
pub use self::__buffa::view::AssetBalanceOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetBalancesResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetBalancesResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetBalanceHistoryRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetBalanceHistoryRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::BalanceSeriesView;
#[doc(inline)]
pub use self::__buffa::view::BalanceSeriesOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetBalanceHistoryResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetBalanceHistoryResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::AccountGroupingView;
#[doc(inline)]
pub use self::__buffa::view::AccountGroupingOwnedView;
#[doc(inline)]
pub use self::__buffa::view::AssetGroupingView;
#[doc(inline)]
pub use self::__buffa::view::AssetGroupingOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetEquityHistorySeriesRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetEquityHistorySeriesRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::EquitySeriesView;
#[doc(inline)]
pub use self::__buffa::view::EquitySeriesOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetEquityHistorySeriesResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetEquityHistorySeriesResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListTransfersRequestView;
#[doc(inline)]
pub use self::__buffa::view::ListTransfersRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::TransferSideView;
#[doc(inline)]
pub use self::__buffa::view::TransferSideOwnedView;
#[doc(inline)]
pub use self::__buffa::view::TransferRowView;
#[doc(inline)]
pub use self::__buffa::view::TransferRowOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListTransfersResponseView;
#[doc(inline)]
pub use self::__buffa::view::ListTransfersResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListHoldsRequestView;
#[doc(inline)]
pub use self::__buffa::view::ListHoldsRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HoldRowView;
#[doc(inline)]
pub use self::__buffa::view::HoldRowOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListHoldsResponseView;
#[doc(inline)]
pub use self::__buffa::view::ListHoldsResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ErrorDetailView;
#[doc(inline)]
pub use self::__buffa::view::ErrorDetailOwnedView;
#[doc(inline)]
pub use self::__buffa::register_types;