polyester-sdk 0.1.0-alpha.27

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

/// SparklineInterval identifies the time range and sampling resolution for a
/// sparkline.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum SparklineInterval {
    /// Unspecified interval. When requested, server may default to 24H.
    SPARKLINE_INTERVAL_UNSPECIFIED = 0i32,
    /// 1 hour sparkline. Typically returns up to 60 points (1-minute buckets).
    SPARKLINE_1H = 1i32,
    /// 24 hour sparkline. Typically returns up to 96 points (15-minute buckets).
    SPARKLINE_24H = 2i32,
    /// 1 week sparkline. Typically returns up to 168 points (1-hour buckets).
    SPARKLINE_1W = 3i32,
    /// 1 month sparkline. Typically returns up to 180 points (4-hour buckets).
    SPARKLINE_1M = 4i32,
}
impl SparklineInterval {
    ///Idiomatic alias for [`Self::SPARKLINE_INTERVAL_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SparklineIntervalUnspecified: Self = Self::SPARKLINE_INTERVAL_UNSPECIFIED;
    ///Idiomatic alias for [`Self::SPARKLINE_1H`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sparkline1h: Self = Self::SPARKLINE_1H;
    ///Idiomatic alias for [`Self::SPARKLINE_24H`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sparkline24h: Self = Self::SPARKLINE_24H;
    ///Idiomatic alias for [`Self::SPARKLINE_1W`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sparkline1w: Self = Self::SPARKLINE_1W;
    ///Idiomatic alias for [`Self::SPARKLINE_1M`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sparkline1m: Self = Self::SPARKLINE_1M;
}
impl ::core::default::Default for SparklineInterval {
    fn default() -> Self {
        Self::SPARKLINE_INTERVAL_UNSPECIFIED
    }
}
impl ::serde::Serialize for SparklineInterval {
    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 SparklineInterval {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = SparklineInterval;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(SparklineInterval)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<SparklineInterval, E> {
                <SparklineInterval 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<SparklineInterval, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SparklineInterval 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<SparklineInterval, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SparklineInterval 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<SparklineInterval, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for SparklineInterval {
    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 SparklineInterval {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::SPARKLINE_INTERVAL_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::SPARKLINE_1H),
            2i32 => ::core::option::Option::Some(Self::SPARKLINE_24H),
            3i32 => ::core::option::Option::Some(Self::SPARKLINE_1W),
            4i32 => ::core::option::Option::Some(Self::SPARKLINE_1M),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::SPARKLINE_INTERVAL_UNSPECIFIED => "SPARKLINE_INTERVAL_UNSPECIFIED",
            Self::SPARKLINE_1H => "SPARKLINE_1H",
            Self::SPARKLINE_24H => "SPARKLINE_24H",
            Self::SPARKLINE_1W => "SPARKLINE_1W",
            Self::SPARKLINE_1M => "SPARKLINE_1M",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "SPARKLINE_INTERVAL_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::SPARKLINE_INTERVAL_UNSPECIFIED)
            }
            "SPARKLINE_1H" => ::core::option::Option::Some(Self::SPARKLINE_1H),
            "SPARKLINE_24H" => ::core::option::Option::Some(Self::SPARKLINE_24H),
            "SPARKLINE_1W" => ::core::option::Option::Some(Self::SPARKLINE_1W),
            "SPARKLINE_1M" => ::core::option::Option::Some(Self::SPARKLINE_1M),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::SPARKLINE_INTERVAL_UNSPECIFIED,
            Self::SPARKLINE_1H,
            Self::SPARKLINE_24H,
            Self::SPARKLINE_1W,
            Self::SPARKLINE_1M,
        ]
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum MarketOrderBy {
    MARKET_ORDER_BY_UNSPECIFIED = 0i32,
    /// Sort by absolute 24h change (basis points).
    ORDER_BY_CHANGE_24H_BPS = 1i32,
    /// Sort by 24h quote volume scaled by the pair's quote_quantity_scale from
    /// GetSpotConfig.
    ORDER_BY_VOLUME_24H_QUOTE = 2i32,
    /// Sort by last price in quote units scaled by 1e6.
    ORDER_BY_LAST_PRICE = 3i32,
    /// Sort by listing time (new listings first).
    ORDER_BY_DATE_ADDED = 4i32,
}
impl MarketOrderBy {
    ///Idiomatic alias for [`Self::MARKET_ORDER_BY_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MarketOrderByUnspecified: Self = Self::MARKET_ORDER_BY_UNSPECIFIED;
    ///Idiomatic alias for [`Self::ORDER_BY_CHANGE_24H_BPS`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const OrderByChange24hBps: Self = Self::ORDER_BY_CHANGE_24H_BPS;
    ///Idiomatic alias for [`Self::ORDER_BY_VOLUME_24H_QUOTE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const OrderByVolume24hQuote: Self = Self::ORDER_BY_VOLUME_24H_QUOTE;
    ///Idiomatic alias for [`Self::ORDER_BY_LAST_PRICE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const OrderByLastPrice: Self = Self::ORDER_BY_LAST_PRICE;
    ///Idiomatic alias for [`Self::ORDER_BY_DATE_ADDED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const OrderByDateAdded: Self = Self::ORDER_BY_DATE_ADDED;
}
impl ::core::default::Default for MarketOrderBy {
    fn default() -> Self {
        Self::MARKET_ORDER_BY_UNSPECIFIED
    }
}
impl ::serde::Serialize for MarketOrderBy {
    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 MarketOrderBy {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = MarketOrderBy;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(MarketOrderBy)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<MarketOrderBy, E> {
                <MarketOrderBy 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<MarketOrderBy, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <MarketOrderBy 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<MarketOrderBy, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <MarketOrderBy 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<MarketOrderBy, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for MarketOrderBy {
    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 MarketOrderBy {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::MARKET_ORDER_BY_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::ORDER_BY_CHANGE_24H_BPS),
            2i32 => ::core::option::Option::Some(Self::ORDER_BY_VOLUME_24H_QUOTE),
            3i32 => ::core::option::Option::Some(Self::ORDER_BY_LAST_PRICE),
            4i32 => ::core::option::Option::Some(Self::ORDER_BY_DATE_ADDED),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::MARKET_ORDER_BY_UNSPECIFIED => "MARKET_ORDER_BY_UNSPECIFIED",
            Self::ORDER_BY_CHANGE_24H_BPS => "ORDER_BY_CHANGE_24H_BPS",
            Self::ORDER_BY_VOLUME_24H_QUOTE => "ORDER_BY_VOLUME_24H_QUOTE",
            Self::ORDER_BY_LAST_PRICE => "ORDER_BY_LAST_PRICE",
            Self::ORDER_BY_DATE_ADDED => "ORDER_BY_DATE_ADDED",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "MARKET_ORDER_BY_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::MARKET_ORDER_BY_UNSPECIFIED)
            }
            "ORDER_BY_CHANGE_24H_BPS" => {
                ::core::option::Option::Some(Self::ORDER_BY_CHANGE_24H_BPS)
            }
            "ORDER_BY_VOLUME_24H_QUOTE" => {
                ::core::option::Option::Some(Self::ORDER_BY_VOLUME_24H_QUOTE)
            }
            "ORDER_BY_LAST_PRICE" => {
                ::core::option::Option::Some(Self::ORDER_BY_LAST_PRICE)
            }
            "ORDER_BY_DATE_ADDED" => {
                ::core::option::Option::Some(Self::ORDER_BY_DATE_ADDED)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::MARKET_ORDER_BY_UNSPECIFIED,
            Self::ORDER_BY_CHANGE_24H_BPS,
            Self::ORDER_BY_VOLUME_24H_QUOTE,
            Self::ORDER_BY_LAST_PRICE,
            Self::ORDER_BY_DATE_ADDED,
        ]
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum SortDirection {
    SORT_DIRECTION_UNSPECIFIED = 0i32,
    /// Ascending (oldest/lowest first).
    SORT_ASC = 1i32,
    /// Descending (newest/highest first).
    SORT_DESC = 2i32,
}
impl SortDirection {
    ///Idiomatic alias for [`Self::SORT_DIRECTION_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SortDirectionUnspecified: Self = Self::SORT_DIRECTION_UNSPECIFIED;
    ///Idiomatic alias for [`Self::SORT_ASC`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SortAsc: Self = Self::SORT_ASC;
    ///Idiomatic alias for [`Self::SORT_DESC`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SortDesc: Self = Self::SORT_DESC;
}
impl ::core::default::Default for SortDirection {
    fn default() -> Self {
        Self::SORT_DIRECTION_UNSPECIFIED
    }
}
impl ::serde::Serialize for SortDirection {
    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 SortDirection {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = SortDirection;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(SortDirection)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<SortDirection, E> {
                <SortDirection 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<SortDirection, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SortDirection 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<SortDirection, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SortDirection 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<SortDirection, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for SortDirection {
    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 SortDirection {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::SORT_DIRECTION_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::SORT_ASC),
            2i32 => ::core::option::Option::Some(Self::SORT_DESC),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::SORT_DIRECTION_UNSPECIFIED => "SORT_DIRECTION_UNSPECIFIED",
            Self::SORT_ASC => "SORT_ASC",
            Self::SORT_DESC => "SORT_DESC",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "SORT_DIRECTION_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::SORT_DIRECTION_UNSPECIFIED)
            }
            "SORT_ASC" => ::core::option::Option::Some(Self::SORT_ASC),
            "SORT_DESC" => ::core::option::Option::Some(Self::SORT_DESC),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::SORT_DIRECTION_UNSPECIFIED, Self::SORT_ASC, Self::SORT_DESC]
    }
}
/// ErrorCode is a stable domain error code enum for Market Overview.
/// It is used for consistent error surfaces across ConnectRPC and REST.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum ErrorCode {
    ERROR_CODE_UNSPECIFIED = 0i32,
    ERROR_CODE_BAD_REQUEST = 1i32,
    ERROR_CODE_INVALID_ARGUMENT = 2i32,
    ERROR_CODE_NOT_FOUND = 3i32,
    ERROR_CODE_UNAVAILABLE = 4i32,
    ERROR_CODE_UPSTREAM_ERROR = 5i32,
}
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_INVALID_ARGUMENT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const InvalidArgument: Self = Self::ERROR_CODE_INVALID_ARGUMENT;
    ///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_UNAVAILABLE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unavailable: Self = Self::ERROR_CODE_UNAVAILABLE;
    ///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_INVALID_ARGUMENT),
            3i32 => ::core::option::Option::Some(Self::ERROR_CODE_NOT_FOUND),
            4i32 => ::core::option::Option::Some(Self::ERROR_CODE_UNAVAILABLE),
            5i32 => ::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_INVALID_ARGUMENT => "ERROR_CODE_INVALID_ARGUMENT",
            Self::ERROR_CODE_NOT_FOUND => "ERROR_CODE_NOT_FOUND",
            Self::ERROR_CODE_UNAVAILABLE => "ERROR_CODE_UNAVAILABLE",
            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_INVALID_ARGUMENT" => {
                ::core::option::Option::Some(Self::ERROR_CODE_INVALID_ARGUMENT)
            }
            "ERROR_CODE_NOT_FOUND" => {
                ::core::option::Option::Some(Self::ERROR_CODE_NOT_FOUND)
            }
            "ERROR_CODE_UNAVAILABLE" => {
                ::core::option::Option::Some(Self::ERROR_CODE_UNAVAILABLE)
            }
            "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_INVALID_ARGUMENT,
            Self::ERROR_CODE_NOT_FOUND,
            Self::ERROR_CODE_UNAVAILABLE,
            Self::ERROR_CODE_UPSTREAM_ERROR,
        ]
    }
}
/// ErrorDetail carries a typed domain error code for machine-readable handling.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ErrorDetail {
    /// Stable error code for programmatic matching.
    ///
    /// 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/marketoverview.v1.ErrorDetail";
}
::buffa::impl_default_instance!(ErrorDetail);
impl ::buffa::MessageName for ErrorDetail {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "ErrorDetail";
    const FULL_NAME: &'static str = "marketoverview.v1.ErrorDetail";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.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 = "marketoverview.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/marketoverview.v1.ErrorDetail",
    to_json: ::buffa::type_registry::any_to_json::<ErrorDetail>,
    from_json: ::buffa::type_registry::any_from_json::<ErrorDetail>,
    is_wkt: false,
};
/// Sparkline contains newest-first close prices for one time range.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct Sparkline {
    /// Time range and sampling resolution represented by these close prices.
    ///
    /// Field 1: `interval`
    #[serde(
        rename = "interval",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub interval: ::buffa::EnumValue<SparklineInterval>,
    /// Newest-first close prices in quote units scaled by 1e6.
    ///
    /// Field 2: `close_ticks`
    #[serde(
        rename = "closeTicks",
        alias = "close_ticks",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub close_ticks: ::buffa::alloc::vec::Vec<i64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Sparkline {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Sparkline")
            .field("interval", &self.interval)
            .field("close_ticks", &self.close_ticks)
            .finish()
    }
}
impl Sparkline {
    /// 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/marketoverview.v1.Sparkline";
}
::buffa::impl_default_instance!(Sparkline);
impl ::buffa::MessageName for Sparkline {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "Sparkline";
    const FULL_NAME: &'static str = "marketoverview.v1.Sparkline";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.Sparkline";
}
impl ::buffa::Message for Sparkline {
    /// 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.interval.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.close_ticks.is_empty() {
            let payload: u32 = self
                .close_ticks
                .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.interval.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.close_ticks.is_empty() {
            let payload: u32 = self
                .close_ticks
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(2u32, payload, buf);
            for &v in &self.close_ticks {
                ::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.interval = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            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.close_ticks.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.close_ticks
                            .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.close_ticks.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.interval = ::buffa::EnumValue::from(0);
        self.close_ticks.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Sparkline {
    const PROTO_FQN: &'static str = "marketoverview.v1.Sparkline";
    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 Sparkline {
    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 __SPARKLINE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketoverview.v1.Sparkline",
    to_json: ::buffa::type_registry::any_to_json::<Sparkline>,
    from_json: ::buffa::type_registry::any_from_json::<Sparkline>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct MarketOverview {
    /// Numeric spot market identifier.
    ///
    /// Field 1: `symbol_id`
    #[serde(
        rename = "symbolId",
        alias = "symbol_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub symbol_id: u32,
    /// Canonical pair symbol, e.g. "BTC-USDT".
    ///
    /// 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,
    /// Last traded price in quote units scaled by 1e6.
    ///
    /// Field 3: `last_price_ticks`
    #[serde(
        rename = "lastPriceTicks",
        alias = "last_price_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub last_price_ticks: i64,
    /// Last trade timestamp in nanoseconds since epoch.
    ///
    /// Field 4: `last_trade_ts_ns`
    #[serde(
        rename = "lastTradeTsNs",
        alias = "last_trade_ts_ns",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub last_trade_ts_ns: u64,
    /// Rolling 24h change expressed in basis points (bp). Example: +123 = +1.23%.
    ///
    /// Field 5: `change_24h_bps`
    #[serde(
        rename = "change24hBps",
        alias = "change_24h_bps",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub change_24h_bps: i32,
    /// Rolling 24h stats.
    /// Highest traded price in the 24h window, in quote units scaled by 1e6.
    ///
    /// Field 6: `high_24h_ticks`
    #[serde(
        rename = "high24hTicks",
        alias = "high_24h_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub high_24h_ticks: i64,
    /// Lowest traded price in the 24h window, in quote units scaled by 1e6.
    ///
    /// Field 7: `low_24h_ticks`
    #[serde(
        rename = "low24hTicks",
        alias = "low_24h_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub low_24h_ticks: i64,
    /// Rolling 24h base volume scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 8: `volume_24h_base_scaled`
    #[serde(
        rename = "volume24hBaseScaled",
        alias = "volume_24h_base_scaled",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub volume_24h_base_scaled: i64,
    /// Rolling 24h quote volume scaled by the pair's quote_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 14: `volume_24h_quote_scaled`
    #[serde(
        rename = "volume24hQuoteScaled",
        alias = "volume_24h_quote_scaled",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub volume_24h_quote_scaled: i64,
    /// Listing timestamp in nanoseconds since epoch.
    ///
    /// Field 15: `listed_ts_ns`
    #[serde(
        rename = "listedTsNs",
        alias = "listed_ts_ns",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub listed_ts_ns: u64,
    /// Current best bid price in quote units scaled by 1e6.
    ///
    /// Field 9: `best_bid_ticks`
    #[serde(
        rename = "bestBidTicks",
        alias = "best_bid_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub best_bid_ticks: i64,
    /// Best bid quantity scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 10: `best_bid_qty_scaled`
    #[serde(
        rename = "bestBidQtyScaled",
        alias = "best_bid_qty_scaled",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub best_bid_qty_scaled: i64,
    /// Current best ask price in quote units scaled by 1e6.
    ///
    /// Field 11: `best_ask_ticks`
    #[serde(
        rename = "bestAskTicks",
        alias = "best_ask_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub best_ask_ticks: i64,
    /// Best ask quantity scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 12: `best_ask_qty_scaled`
    #[serde(
        rename = "bestAskQtyScaled",
        alias = "best_ask_qty_scaled",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub best_ask_qty_scaled: i64,
    /// Optional sparklines (requested explicitly).
    ///
    /// Field 13: `sparklines`
    #[serde(
        rename = "sparklines",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub sparklines: ::buffa::alloc::vec::Vec<Sparkline>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for MarketOverview {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MarketOverview")
            .field("symbol_id", &self.symbol_id)
            .field("symbol", &self.symbol)
            .field("last_price_ticks", &self.last_price_ticks)
            .field("last_trade_ts_ns", &self.last_trade_ts_ns)
            .field("change_24h_bps", &self.change_24h_bps)
            .field("high_24h_ticks", &self.high_24h_ticks)
            .field("low_24h_ticks", &self.low_24h_ticks)
            .field("volume_24h_base_scaled", &self.volume_24h_base_scaled)
            .field("volume_24h_quote_scaled", &self.volume_24h_quote_scaled)
            .field("listed_ts_ns", &self.listed_ts_ns)
            .field("best_bid_ticks", &self.best_bid_ticks)
            .field("best_bid_qty_scaled", &self.best_bid_qty_scaled)
            .field("best_ask_ticks", &self.best_ask_ticks)
            .field("best_ask_qty_scaled", &self.best_ask_qty_scaled)
            .field("sparklines", &self.sparklines)
            .finish()
    }
}
impl MarketOverview {
    /// 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/marketoverview.v1.MarketOverview";
}
::buffa::impl_default_instance!(MarketOverview);
impl ::buffa::MessageName for MarketOverview {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "MarketOverview";
    const FULL_NAME: &'static str = "marketoverview.v1.MarketOverview";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.MarketOverview";
}
impl ::buffa::Message for MarketOverview {
    /// 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.symbol_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.symbol_id) as u32;
        }
        if !self.symbol.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.symbol) as u32;
        }
        if self.last_price_ticks != 0i64 {
            size
                += 1u32
                    + ::buffa::types::int64_encoded_len(self.last_price_ticks) as u32;
        }
        if self.last_trade_ts_ns != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.last_trade_ts_ns) as u32;
        }
        if self.change_24h_bps != 0i32 {
            size += 1u32 + ::buffa::types::int32_encoded_len(self.change_24h_bps) as u32;
        }
        if self.high_24h_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.high_24h_ticks) as u32;
        }
        if self.low_24h_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.low_24h_ticks) as u32;
        }
        if self.volume_24h_base_scaled != 0i64 {
            size
                += 1u32
                    + ::buffa::types::int64_encoded_len(self.volume_24h_base_scaled)
                        as u32;
        }
        if self.best_bid_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.best_bid_ticks) as u32;
        }
        if self.best_bid_qty_scaled != 0i64 {
            size
                += 1u32
                    + ::buffa::types::int64_encoded_len(self.best_bid_qty_scaled) as u32;
        }
        if self.best_ask_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.best_ask_ticks) as u32;
        }
        if self.best_ask_qty_scaled != 0i64 {
            size
                += 1u32
                    + ::buffa::types::int64_encoded_len(self.best_ask_qty_scaled) as u32;
        }
        for v in &self.sparklines {
            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.volume_24h_quote_scaled != 0i64 {
            size
                += 1u32
                    + ::buffa::types::int64_encoded_len(self.volume_24h_quote_scaled)
                        as u32;
        }
        if self.listed_ts_ns != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.listed_ts_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.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        if !self.symbol.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.symbol, buf);
        }
        if self.last_price_ticks != 0i64 {
            ::buffa::types::put_int64_field(3u32, self.last_price_ticks, buf);
        }
        if self.last_trade_ts_ns != 0u64 {
            ::buffa::types::put_uint64_field(4u32, self.last_trade_ts_ns, buf);
        }
        if self.change_24h_bps != 0i32 {
            ::buffa::types::put_int32_field(5u32, self.change_24h_bps, buf);
        }
        if self.high_24h_ticks != 0i64 {
            ::buffa::types::put_int64_field(6u32, self.high_24h_ticks, buf);
        }
        if self.low_24h_ticks != 0i64 {
            ::buffa::types::put_int64_field(7u32, self.low_24h_ticks, buf);
        }
        if self.volume_24h_base_scaled != 0i64 {
            ::buffa::types::put_int64_field(8u32, self.volume_24h_base_scaled, buf);
        }
        if self.best_bid_ticks != 0i64 {
            ::buffa::types::put_int64_field(9u32, self.best_bid_ticks, buf);
        }
        if self.best_bid_qty_scaled != 0i64 {
            ::buffa::types::put_int64_field(10u32, self.best_bid_qty_scaled, buf);
        }
        if self.best_ask_ticks != 0i64 {
            ::buffa::types::put_int64_field(11u32, self.best_ask_ticks, buf);
        }
        if self.best_ask_qty_scaled != 0i64 {
            ::buffa::types::put_int64_field(12u32, self.best_ask_qty_scaled, buf);
        }
        for v in &self.sparklines {
            ::buffa::types::put_len_delimited_header(13u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if self.volume_24h_quote_scaled != 0i64 {
            ::buffa::types::put_int64_field(14u32, self.volume_24h_quote_scaled, buf);
        }
        if self.listed_ts_ns != 0u64 {
            ::buffa::types::put_uint64_field(15u32, self.listed_ts_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::Varint,
                )?;
                self.symbol_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)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.last_price_ticks = ::buffa::types::decode_int64(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.last_trade_ts_ns = ::buffa::types::decode_uint64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.change_24h_bps = ::buffa::types::decode_int32(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.high_24h_ticks = ::buffa::types::decode_int64(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.low_24h_ticks = ::buffa::types::decode_int64(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.volume_24h_base_scaled = ::buffa::types::decode_int64(buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_bid_ticks = ::buffa::types::decode_int64(buf)?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_bid_qty_scaled = ::buffa::types::decode_int64(buf)?;
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_ask_ticks = ::buffa::types::decode_int64(buf)?;
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_ask_qty_scaled = ::buffa::types::decode_int64(buf)?;
            }
            13u32 => {
                ::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.sparklines.push(elem);
            }
            14u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.volume_24h_quote_scaled = ::buffa::types::decode_int64(buf)?;
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.listed_ts_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.symbol_id = 0u32;
        self.symbol.clear();
        self.last_price_ticks = 0i64;
        self.last_trade_ts_ns = 0u64;
        self.change_24h_bps = 0i32;
        self.high_24h_ticks = 0i64;
        self.low_24h_ticks = 0i64;
        self.volume_24h_base_scaled = 0i64;
        self.best_bid_ticks = 0i64;
        self.best_bid_qty_scaled = 0i64;
        self.best_ask_ticks = 0i64;
        self.best_ask_qty_scaled = 0i64;
        self.sparklines.clear();
        self.volume_24h_quote_scaled = 0i64;
        self.listed_ts_ns = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MarketOverview {
    const PROTO_FQN: &'static str = "marketoverview.v1.MarketOverview";
    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 MarketOverview {
    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 __MARKET_OVERVIEW_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketoverview.v1.MarketOverview",
    to_json: ::buffa::type_registry::any_to_json::<MarketOverview>,
    from_json: ::buffa::type_registry::any_from_json::<MarketOverview>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListMarketOverviewRequest {
    /// Filter by specific symbols; when empty, returns all enabled markets.
    ///
    /// Field 1: `symbols`
    #[serde(
        rename = "symbols",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub symbols: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Maximum number of markets to return. Defaults to 50 when omitted; maximum
    /// is 2000.
    ///
    /// 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,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to symbols, sort key, and sort direction. Sparkline options affect
    /// only response enrichment and may change between pages.
    ///
    /// Field 3: `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,
    /// Sort key. When unset/UNSPECIFIED, defaults to 24h quote volume.
    ///
    /// Field 4: `order_by`
    #[serde(
        rename = "orderBy",
        alias = "order_by",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub order_by: ::buffa::EnumValue<MarketOrderBy>,
    /// Sort direction (DESC=newest/highest first).
    ///
    /// Field 5: `sort`
    #[serde(
        rename = "sort",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub sort: ::buffa::EnumValue<SortDirection>,
    /// When true, include sparklines in each MarketOverview.
    ///
    /// Field 6: `include_sparklines`
    #[serde(
        rename = "includeSparklines",
        alias = "include_sparklines",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub include_sparklines: bool,
    /// Which sparklines to include. If empty and include_sparklines is true,
    /// server defaults to 24h.
    ///
    /// Field 7: `sparkline_intervals`
    #[serde(
        rename = "sparklineIntervals",
        alias = "sparkline_intervals",
        with = "::buffa::json_helpers::repeated_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub sparkline_intervals: ::buffa::alloc::vec::Vec<
        ::buffa::EnumValue<SparklineInterval>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListMarketOverviewRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListMarketOverviewRequest")
            .field("symbols", &self.symbols)
            .field("limit", &self.limit)
            .field("page_token", &self.page_token)
            .field("order_by", &self.order_by)
            .field("sort", &self.sort)
            .field("include_sparklines", &self.include_sparklines)
            .field("sparkline_intervals", &self.sparkline_intervals)
            .finish()
    }
}
impl ListMarketOverviewRequest {
    /// 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/marketoverview.v1.ListMarketOverviewRequest";
}
::buffa::impl_default_instance!(ListMarketOverviewRequest);
impl ::buffa::MessageName for ListMarketOverviewRequest {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "ListMarketOverviewRequest";
    const FULL_NAME: &'static str = "marketoverview.v1.ListMarketOverviewRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.ListMarketOverviewRequest";
}
impl ::buffa::Message for ListMarketOverviewRequest {
    /// 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.symbols {
            size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) as u32;
        }
        {
            let val = self.order_by.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.sort.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.include_sparklines {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.sparkline_intervals.is_empty() {
            let payload: u32 = self
                .sparkline_intervals
                .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 _;
        for v in &self.symbols {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.limit, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.page_token, buf);
        }
        {
            let val = self.order_by.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(4u32, val, buf);
            }
        }
        {
            let val = self.sort.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(5u32, val, buf);
            }
        }
        if self.include_sparklines {
            ::buffa::types::put_bool_field(6u32, self.include_sparklines, buf);
        }
        if !self.sparkline_intervals.is_empty() {
            let payload: u32 = self
                .sparkline_intervals
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(7u32, payload, buf);
            for v in &self.sparkline_intervals {
                ::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::LengthDelimited,
                )?;
                self.symbols.push(::buffa::types::decode_string(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::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.order_by = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.sort = ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.include_sparklines = ::buffa::types::decode_bool(buf)?;
            }
            7u32 => {
                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.sparkline_intervals.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.sparkline_intervals
                            .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.sparkline_intervals
                        .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.symbols.clear();
        self.limit = 0u32;
        self.page_token.clear();
        self.order_by = ::buffa::EnumValue::from(0);
        self.sort = ::buffa::EnumValue::from(0);
        self.include_sparklines = false;
        self.sparkline_intervals.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListMarketOverviewRequest {
    const PROTO_FQN: &'static str = "marketoverview.v1.ListMarketOverviewRequest";
    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 ListMarketOverviewRequest {
    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_MARKET_OVERVIEW_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketoverview.v1.ListMarketOverviewRequest",
    to_json: ::buffa::type_registry::any_to_json::<ListMarketOverviewRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ListMarketOverviewRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListMarketOverviewResponse {
    /// Market overview rows for the requested page.
    ///
    /// Field 1: `markets`
    #[serde(
        rename = "markets",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub markets: ::buffa::alloc::vec::Vec<MarketOverview>,
    /// 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 ListMarketOverviewResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListMarketOverviewResponse")
            .field("markets", &self.markets)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl ListMarketOverviewResponse {
    /// 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/marketoverview.v1.ListMarketOverviewResponse";
}
::buffa::impl_default_instance!(ListMarketOverviewResponse);
impl ::buffa::MessageName for ListMarketOverviewResponse {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "ListMarketOverviewResponse";
    const FULL_NAME: &'static str = "marketoverview.v1.ListMarketOverviewResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.ListMarketOverviewResponse";
}
impl ::buffa::Message for ListMarketOverviewResponse {
    /// 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.markets {
            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.markets {
            ::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.markets.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.markets.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListMarketOverviewResponse {
    const PROTO_FQN: &'static str = "marketoverview.v1.ListMarketOverviewResponse";
    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 ListMarketOverviewResponse {
    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_MARKET_OVERVIEW_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketoverview.v1.ListMarketOverviewResponse",
    to_json: ::buffa::type_registry::any_to_json::<ListMarketOverviewResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ListMarketOverviewResponse>,
    is_wkt: false,
};
/// MarketOverviewBatch is a websocket payload carrying batched market overview
/// updates. It is published to a single all-markets channel at a fixed cadence.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct MarketOverviewBatch {
    /// Market overviews included in this batch.
    ///
    /// Field 1: `markets`
    #[serde(
        rename = "markets",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub markets: ::buffa::alloc::vec::Vec<MarketOverview>,
    /// Batch publish timestamp in nanoseconds since epoch.
    ///
    /// Field 2: `ts_ns`
    #[serde(
        rename = "tsNs",
        alias = "ts_ns",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_ns: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for MarketOverviewBatch {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MarketOverviewBatch")
            .field("markets", &self.markets)
            .field("ts_ns", &self.ts_ns)
            .finish()
    }
}
impl MarketOverviewBatch {
    /// 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/marketoverview.v1.MarketOverviewBatch";
}
::buffa::impl_default_instance!(MarketOverviewBatch);
impl ::buffa::MessageName for MarketOverviewBatch {
    const PACKAGE: &'static str = "marketoverview.v1";
    const NAME: &'static str = "MarketOverviewBatch";
    const FULL_NAME: &'static str = "marketoverview.v1.MarketOverviewBatch";
    const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.MarketOverviewBatch";
}
impl ::buffa::Message for MarketOverviewBatch {
    /// 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.markets {
            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.ts_ns != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_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 _;
        for v in &self.markets {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if self.ts_ns != 0u64 {
            ::buffa::types::put_uint64_field(2u32, self.ts_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::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.markets.push(elem);
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_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.markets.clear();
        self.ts_ns = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MarketOverviewBatch {
    const PROTO_FQN: &'static str = "marketoverview.v1.MarketOverviewBatch";
    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 MarketOverviewBatch {
    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 __MARKET_OVERVIEW_BATCH_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketoverview.v1.MarketOverviewBatch",
    to_json: ::buffa::type_registry::any_to_json::<MarketOverviewBatch>,
    from_json: ::buffa::type_registry::any_from_json::<MarketOverviewBatch>,
    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::*;
        /// ErrorDetail carries a typed domain error code for machine-readable handling.
        #[derive(Clone, Debug, Default)]
        pub struct ErrorDetailView<'a> {
            /// Stable error code for programmatic matching.
            ///
            /// 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 = "marketoverview.v1";
            const NAME: &'static str = "ErrorDetail";
            const FULL_NAME: &'static str = "marketoverview.v1.ErrorDetail";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.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 for programmatic matching.
            ///
            /// 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)
            }
        }
        /// Sparkline contains newest-first close prices for one time range.
        #[derive(Clone, Debug, Default)]
        pub struct SparklineView<'a> {
            /// Time range and sampling resolution represented by these close prices.
            ///
            /// Field 1: `interval`
            pub interval: ::buffa::EnumValue<super::super::SparklineInterval>,
            /// Newest-first close prices in quote units scaled by 1e6.
            ///
            /// Field 2: `close_ticks`
            pub close_ticks: ::buffa::RepeatedView<'a, i64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for SparklineView<'a> {
            type Owned = super::super::Sparkline;
            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.interval = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    2u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.close_ticks
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.close_ticks
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.close_ticks
                                .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::Sparkline, ::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::Sparkline, ::buffa::DecodeError> {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::Sparkline {
                    interval: self.interval,
                    close_ticks: self.close_ticks.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for SparklineView<'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.interval.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.close_ticks.is_empty() {
                    let payload: u32 = self
                        .close_ticks
                        .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.interval.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(1u32, val, buf);
                    }
                }
                if !self.close_ticks.is_empty() {
                    let payload: u32 = self
                        .close_ticks
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(2u32, payload, buf);
                    for &v in &self.close_ticks {
                        ::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 SparklineView<'__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.interval,
                ) {
                    __map.serialize_entry("interval", &self.interval)?;
                }
                if !self.close_ticks.is_empty() {
                    __map
                        .serialize_entry(
                            "closeTicks",
                            &::buffa::json_helpers::RepeatedJson(&self.close_ticks),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for SparklineView<'a> {
            const PACKAGE: &'static str = "marketoverview.v1";
            const NAME: &'static str = "Sparkline";
            const FULL_NAME: &'static str = "marketoverview.v1.Sparkline";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.Sparkline";
        }
        ::buffa::impl_default_view_instance!(SparklineView);
        ::buffa::impl_view_reborrow!(SparklineView);
        /** Self-contained, `'static` owned view of a `Sparkline` message.

 Wraps [`::buffa::OwnedView`]`<`[`SparklineView`]`<'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 [`SparklineView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct SparklineOwnedView(::buffa::OwnedView<SparklineView<'static>>);
        impl SparklineOwnedView {
            /// 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(
                    SparklineOwnedView(::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(
                    SparklineOwnedView(
                        ::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::Sparkline,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    SparklineOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`SparklineView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &SparklineView<'_> {
                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::Sparkline, ::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()
            }
            /// Time range and sampling resolution represented by these close prices.
            ///
            /// Field 1: `interval`
            #[must_use]
            pub fn interval(
                &self,
            ) -> ::buffa::EnumValue<super::super::SparklineInterval> {
                self.0.reborrow().interval
            }
            /// Newest-first close prices in quote units scaled by 1e6.
            ///
            /// Field 2: `close_ticks`
            #[must_use]
            pub fn close_ticks(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().close_ticks
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<SparklineView<'static>>>
        for SparklineOwnedView {
            fn from(inner: ::buffa::OwnedView<SparklineView<'static>>) -> Self {
                SparklineOwnedView(inner)
            }
        }
        impl ::core::convert::From<SparklineOwnedView>
        for ::buffa::OwnedView<SparklineView<'static>> {
            fn from(wrapper: SparklineOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<SparklineView<'static>>>
        for SparklineOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<SparklineView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::Sparkline {
            type View<'a> = SparklineView<'a>;
            type ViewHandle = SparklineOwnedView;
        }
        impl ::serde::Serialize for SparklineOwnedView {
            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 MarketOverviewView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Canonical pair symbol, e.g. "BTC-USDT".
            ///
            /// Field 2: `symbol`
            pub symbol: &'a str,
            /// Last traded price in quote units scaled by 1e6.
            ///
            /// Field 3: `last_price_ticks`
            pub last_price_ticks: i64,
            /// Last trade timestamp in nanoseconds since epoch.
            ///
            /// Field 4: `last_trade_ts_ns`
            pub last_trade_ts_ns: u64,
            /// Rolling 24h change expressed in basis points (bp). Example: +123 = +1.23%.
            ///
            /// Field 5: `change_24h_bps`
            pub change_24h_bps: i32,
            /// Rolling 24h stats.
            /// Highest traded price in the 24h window, in quote units scaled by 1e6.
            ///
            /// Field 6: `high_24h_ticks`
            pub high_24h_ticks: i64,
            /// Lowest traded price in the 24h window, in quote units scaled by 1e6.
            ///
            /// Field 7: `low_24h_ticks`
            pub low_24h_ticks: i64,
            /// Rolling 24h base volume scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume_24h_base_scaled`
            pub volume_24h_base_scaled: i64,
            /// Rolling 24h quote volume scaled by the pair's quote_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 14: `volume_24h_quote_scaled`
            pub volume_24h_quote_scaled: i64,
            /// Listing timestamp in nanoseconds since epoch.
            ///
            /// Field 15: `listed_ts_ns`
            pub listed_ts_ns: u64,
            /// Current best bid price in quote units scaled by 1e6.
            ///
            /// Field 9: `best_bid_ticks`
            pub best_bid_ticks: i64,
            /// Best bid quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 10: `best_bid_qty_scaled`
            pub best_bid_qty_scaled: i64,
            /// Current best ask price in quote units scaled by 1e6.
            ///
            /// Field 11: `best_ask_ticks`
            pub best_ask_ticks: i64,
            /// Best ask quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 12: `best_ask_qty_scaled`
            pub best_ask_qty_scaled: i64,
            /// Optional sparklines (requested explicitly).
            ///
            /// Field 13: `sparklines`
            pub sparklines: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::SparklineView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for MarketOverviewView<'a> {
            type Owned = super::super::MarketOverview;
            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.symbol_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)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.last_price_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.last_trade_ts_ns = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.change_24h_bps = ::buffa::types::decode_int32(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.high_24h_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.low_24h_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.volume_24h_base_scaled = ::buffa::types::decode_int64(
                            &mut cur,
                        )?;
                    }
                    14u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.volume_24h_quote_scaled = ::buffa::types::decode_int64(
                            &mut cur,
                        )?;
                    }
                    15u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.listed_ts_ns = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_bid_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    10u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_bid_qty_scaled = ::buffa::types::decode_int64(
                            &mut cur,
                        )?;
                    }
                    11u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_ask_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    12u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_ask_qty_scaled = ::buffa::types::decode_int64(
                            &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)?;
                        view.sparklines
                            .push(
                                <super::super::__buffa::view::SparklineView 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::MarketOverview,
                ::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::MarketOverview,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::MarketOverview {
                    symbol_id: self.symbol_id,
                    symbol: self.symbol.to_string(),
                    last_price_ticks: self.last_price_ticks,
                    last_trade_ts_ns: self.last_trade_ts_ns,
                    change_24h_bps: self.change_24h_bps,
                    high_24h_ticks: self.high_24h_ticks,
                    low_24h_ticks: self.low_24h_ticks,
                    volume_24h_base_scaled: self.volume_24h_base_scaled,
                    volume_24h_quote_scaled: self.volume_24h_quote_scaled,
                    listed_ts_ns: self.listed_ts_ns,
                    best_bid_ticks: self.best_bid_ticks,
                    best_bid_qty_scaled: self.best_bid_qty_scaled,
                    best_ask_ticks: self.best_ask_ticks,
                    best_ask_qty_scaled: self.best_ask_qty_scaled,
                    sparklines: self
                        .sparklines
                        .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 MarketOverviewView<'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.symbol_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.symbol_id) as u32;
                }
                if !self.symbol.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.symbol) as u32;
                }
                if self.last_price_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.last_price_ticks)
                                as u32;
                }
                if self.last_trade_ts_ns != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.last_trade_ts_ns)
                                as u32;
                }
                if self.change_24h_bps != 0i32 {
                    size
                        += 1u32
                            + ::buffa::types::int32_encoded_len(self.change_24h_bps)
                                as u32;
                }
                if self.high_24h_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.high_24h_ticks)
                                as u32;
                }
                if self.low_24h_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.low_24h_ticks)
                                as u32;
                }
                if self.volume_24h_base_scaled != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(
                                self.volume_24h_base_scaled,
                            ) as u32;
                }
                if self.best_bid_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_bid_ticks)
                                as u32;
                }
                if self.best_bid_qty_scaled != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_bid_qty_scaled)
                                as u32;
                }
                if self.best_ask_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_ask_ticks)
                                as u32;
                }
                if self.best_ask_qty_scaled != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_ask_qty_scaled)
                                as u32;
                }
                for v in &self.sparklines {
                    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.volume_24h_quote_scaled != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(
                                self.volume_24h_quote_scaled,
                            ) as u32;
                }
                if self.listed_ts_ns != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.listed_ts_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.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                if !self.symbol.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.symbol, buf);
                }
                if self.last_price_ticks != 0i64 {
                    ::buffa::types::put_int64_field(3u32, self.last_price_ticks, buf);
                }
                if self.last_trade_ts_ns != 0u64 {
                    ::buffa::types::put_uint64_field(4u32, self.last_trade_ts_ns, buf);
                }
                if self.change_24h_bps != 0i32 {
                    ::buffa::types::put_int32_field(5u32, self.change_24h_bps, buf);
                }
                if self.high_24h_ticks != 0i64 {
                    ::buffa::types::put_int64_field(6u32, self.high_24h_ticks, buf);
                }
                if self.low_24h_ticks != 0i64 {
                    ::buffa::types::put_int64_field(7u32, self.low_24h_ticks, buf);
                }
                if self.volume_24h_base_scaled != 0i64 {
                    ::buffa::types::put_int64_field(
                        8u32,
                        self.volume_24h_base_scaled,
                        buf,
                    );
                }
                if self.best_bid_ticks != 0i64 {
                    ::buffa::types::put_int64_field(9u32, self.best_bid_ticks, buf);
                }
                if self.best_bid_qty_scaled != 0i64 {
                    ::buffa::types::put_int64_field(
                        10u32,
                        self.best_bid_qty_scaled,
                        buf,
                    );
                }
                if self.best_ask_ticks != 0i64 {
                    ::buffa::types::put_int64_field(11u32, self.best_ask_ticks, buf);
                }
                if self.best_ask_qty_scaled != 0i64 {
                    ::buffa::types::put_int64_field(
                        12u32,
                        self.best_ask_qty_scaled,
                        buf,
                    );
                }
                for v in &self.sparklines {
                    ::buffa::types::put_len_delimited_header(
                        13u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if self.volume_24h_quote_scaled != 0i64 {
                    ::buffa::types::put_int64_field(
                        14u32,
                        self.volume_24h_quote_scaled,
                        buf,
                    );
                }
                if self.listed_ts_ns != 0u64 {
                    ::buffa::types::put_uint64_field(15u32, self.listed_ts_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 MarketOverviewView<'__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.symbol_id) {
                    __map
                        .serialize_entry(
                            "symbolId",
                            &::buffa::json_helpers::ProtoJson(&self.symbol_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.symbol) {
                    __map.serialize_entry("symbol", self.symbol)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.last_price_ticks) {
                    __map
                        .serialize_entry(
                            "lastPriceTicks",
                            &::buffa::json_helpers::ProtoJson(&self.last_price_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.last_trade_ts_ns) {
                    __map
                        .serialize_entry(
                            "lastTradeTsNs",
                            &::buffa::json_helpers::ProtoJson(&self.last_trade_ts_ns),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i32(&self.change_24h_bps) {
                    __map
                        .serialize_entry(
                            "change24hBps",
                            &::buffa::json_helpers::ProtoJson(&self.change_24h_bps),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.high_24h_ticks) {
                    __map
                        .serialize_entry(
                            "high24hTicks",
                            &::buffa::json_helpers::ProtoJson(&self.high_24h_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.low_24h_ticks) {
                    __map
                        .serialize_entry(
                            "low24hTicks",
                            &::buffa::json_helpers::ProtoJson(&self.low_24h_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(
                    &self.volume_24h_base_scaled,
                ) {
                    __map
                        .serialize_entry(
                            "volume24hBaseScaled",
                            &::buffa::json_helpers::ProtoJson(
                                &self.volume_24h_base_scaled,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(
                    &self.volume_24h_quote_scaled,
                ) {
                    __map
                        .serialize_entry(
                            "volume24hQuoteScaled",
                            &::buffa::json_helpers::ProtoJson(
                                &self.volume_24h_quote_scaled,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.listed_ts_ns) {
                    __map
                        .serialize_entry(
                            "listedTsNs",
                            &::buffa::json_helpers::ProtoJson(&self.listed_ts_ns),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.best_bid_ticks) {
                    __map
                        .serialize_entry(
                            "bestBidTicks",
                            &::buffa::json_helpers::ProtoJson(&self.best_bid_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(
                    &self.best_bid_qty_scaled,
                ) {
                    __map
                        .serialize_entry(
                            "bestBidQtyScaled",
                            &::buffa::json_helpers::ProtoJson(&self.best_bid_qty_scaled),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.best_ask_ticks) {
                    __map
                        .serialize_entry(
                            "bestAskTicks",
                            &::buffa::json_helpers::ProtoJson(&self.best_ask_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(
                    &self.best_ask_qty_scaled,
                ) {
                    __map
                        .serialize_entry(
                            "bestAskQtyScaled",
                            &::buffa::json_helpers::ProtoJson(&self.best_ask_qty_scaled),
                        )?;
                }
                if !self.sparklines.is_empty() {
                    __map.serialize_entry("sparklines", &*self.sparklines)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for MarketOverviewView<'a> {
            const PACKAGE: &'static str = "marketoverview.v1";
            const NAME: &'static str = "MarketOverview";
            const FULL_NAME: &'static str = "marketoverview.v1.MarketOverview";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.MarketOverview";
        }
        ::buffa::impl_default_view_instance!(MarketOverviewView);
        ::buffa::impl_view_reborrow!(MarketOverviewView);
        /** Self-contained, `'static` owned view of a `MarketOverview` message.

 Wraps [`::buffa::OwnedView`]`<`[`MarketOverviewView`]`<'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 [`MarketOverviewView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct MarketOverviewOwnedView(
            ::buffa::OwnedView<MarketOverviewView<'static>>,
        );
        impl MarketOverviewOwnedView {
            /// 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(
                    MarketOverviewOwnedView(::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(
                    MarketOverviewOwnedView(
                        ::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::MarketOverview,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    MarketOverviewOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`MarketOverviewView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &MarketOverviewView<'_> {
                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::MarketOverview,
                ::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()
            }
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Canonical pair symbol, e.g. "BTC-USDT".
            ///
            /// Field 2: `symbol`
            #[must_use]
            pub fn symbol(&self) -> &'_ str {
                self.0.reborrow().symbol
            }
            /// Last traded price in quote units scaled by 1e6.
            ///
            /// Field 3: `last_price_ticks`
            #[must_use]
            pub fn last_price_ticks(&self) -> i64 {
                self.0.reborrow().last_price_ticks
            }
            /// Last trade timestamp in nanoseconds since epoch.
            ///
            /// Field 4: `last_trade_ts_ns`
            #[must_use]
            pub fn last_trade_ts_ns(&self) -> u64 {
                self.0.reborrow().last_trade_ts_ns
            }
            /// Rolling 24h change expressed in basis points (bp). Example: +123 = +1.23%.
            ///
            /// Field 5: `change_24h_bps`
            #[must_use]
            pub fn change_24h_bps(&self) -> i32 {
                self.0.reborrow().change_24h_bps
            }
            /// Rolling 24h stats.
            /// Highest traded price in the 24h window, in quote units scaled by 1e6.
            ///
            /// Field 6: `high_24h_ticks`
            #[must_use]
            pub fn high_24h_ticks(&self) -> i64 {
                self.0.reborrow().high_24h_ticks
            }
            /// Lowest traded price in the 24h window, in quote units scaled by 1e6.
            ///
            /// Field 7: `low_24h_ticks`
            #[must_use]
            pub fn low_24h_ticks(&self) -> i64 {
                self.0.reborrow().low_24h_ticks
            }
            /// Rolling 24h base volume scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume_24h_base_scaled`
            #[must_use]
            pub fn volume_24h_base_scaled(&self) -> i64 {
                self.0.reborrow().volume_24h_base_scaled
            }
            /// Rolling 24h quote volume scaled by the pair's quote_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 14: `volume_24h_quote_scaled`
            #[must_use]
            pub fn volume_24h_quote_scaled(&self) -> i64 {
                self.0.reborrow().volume_24h_quote_scaled
            }
            /// Listing timestamp in nanoseconds since epoch.
            ///
            /// Field 15: `listed_ts_ns`
            #[must_use]
            pub fn listed_ts_ns(&self) -> u64 {
                self.0.reborrow().listed_ts_ns
            }
            /// Current best bid price in quote units scaled by 1e6.
            ///
            /// Field 9: `best_bid_ticks`
            #[must_use]
            pub fn best_bid_ticks(&self) -> i64 {
                self.0.reborrow().best_bid_ticks
            }
            /// Best bid quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 10: `best_bid_qty_scaled`
            #[must_use]
            pub fn best_bid_qty_scaled(&self) -> i64 {
                self.0.reborrow().best_bid_qty_scaled
            }
            /// Current best ask price in quote units scaled by 1e6.
            ///
            /// Field 11: `best_ask_ticks`
            #[must_use]
            pub fn best_ask_ticks(&self) -> i64 {
                self.0.reborrow().best_ask_ticks
            }
            /// Best ask quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 12: `best_ask_qty_scaled`
            #[must_use]
            pub fn best_ask_qty_scaled(&self) -> i64 {
                self.0.reborrow().best_ask_qty_scaled
            }
            /// Optional sparklines (requested explicitly).
            ///
            /// Field 13: `sparklines`
            #[must_use]
            pub fn sparklines(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::SparklineView<'_>,
            > {
                &self.0.reborrow().sparklines
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<MarketOverviewView<'static>>>
        for MarketOverviewOwnedView {
            fn from(inner: ::buffa::OwnedView<MarketOverviewView<'static>>) -> Self {
                MarketOverviewOwnedView(inner)
            }
        }
        impl ::core::convert::From<MarketOverviewOwnedView>
        for ::buffa::OwnedView<MarketOverviewView<'static>> {
            fn from(wrapper: MarketOverviewOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<MarketOverviewView<'static>>>
        for MarketOverviewOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<MarketOverviewView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::MarketOverview {
            type View<'a> = MarketOverviewView<'a>;
            type ViewHandle = MarketOverviewOwnedView;
        }
        impl ::serde::Serialize for MarketOverviewOwnedView {
            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 ListMarketOverviewRequestView<'a> {
            /// Filter by specific symbols; when empty, returns all enabled markets.
            ///
            /// Field 1: `symbols`
            pub symbols: ::buffa::RepeatedView<'a, &'a str>,
            /// Maximum number of markets to return. Defaults to 50 when omitted; maximum
            /// is 2000.
            ///
            /// Field 2: `limit`
            pub limit: u32,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbols, sort key, and sort direction. Sparkline options affect
            /// only response enrichment and may change between pages.
            ///
            /// Field 3: `page_token`
            pub page_token: &'a str,
            /// Sort key. When unset/UNSPECIFIED, defaults to 24h quote volume.
            ///
            /// Field 4: `order_by`
            pub order_by: ::buffa::EnumValue<super::super::MarketOrderBy>,
            /// Sort direction (DESC=newest/highest first).
            ///
            /// Field 5: `sort`
            pub sort: ::buffa::EnumValue<super::super::SortDirection>,
            /// When true, include sparklines in each MarketOverview.
            ///
            /// Field 6: `include_sparklines`
            pub include_sparklines: bool,
            /// Which sparklines to include. If empty and include_sparklines is true,
            /// server defaults to 24h.
            ///
            /// Field 7: `sparkline_intervals`
            pub sparkline_intervals: ::buffa::RepeatedView<
                'a,
                ::buffa::EnumValue<super::super::SparklineInterval>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListMarketOverviewRequestView<'a> {
            type Owned = super::super::ListMarketOverviewRequest;
            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::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.order_by = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.sort = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.include_sparklines = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.symbols.push(::buffa::types::borrow_str(&mut cur)?);
                    }
                    7u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.sparkline_intervals
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.sparkline_intervals
                                    .push(
                                        ::buffa::EnumValue::from(
                                            ::buffa::types::decode_int32(&mut pcur)?,
                                        ),
                                    );
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.sparkline_intervals
                                .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::ListMarketOverviewRequest,
                ::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::ListMarketOverviewRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListMarketOverviewRequest {
                    symbols: self.symbols.iter().map(|s| s.to_string()).collect(),
                    limit: self.limit,
                    page_token: self.page_token.to_string(),
                    order_by: self.order_by,
                    sort: self.sort,
                    include_sparklines: self.include_sparklines,
                    sparkline_intervals: self.sparkline_intervals.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListMarketOverviewRequestView<'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.symbols {
                    size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                as u32;
                }
                {
                    let val = self.order_by.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.sort.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.include_sparklines {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if !self.sparkline_intervals.is_empty() {
                    let payload: u32 = self
                        .sparkline_intervals
                        .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 _;
                for v in &self.symbols {
                    ::buffa::types::put_string_field(1u32, v, buf);
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.limit, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(3u32, &self.page_token, buf);
                }
                {
                    let val = self.order_by.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(4u32, val, buf);
                    }
                }
                {
                    let val = self.sort.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(5u32, val, buf);
                    }
                }
                if self.include_sparklines {
                    ::buffa::types::put_bool_field(6u32, self.include_sparklines, buf);
                }
                if !self.sparkline_intervals.is_empty() {
                    let payload: u32 = self
                        .sparkline_intervals
                        .iter()
                        .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(7u32, payload, buf);
                    for v in &self.sparkline_intervals {
                        ::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 ListMarketOverviewRequestView<'__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.symbols.is_empty() {
                    __map.serialize_entry("symbols", &*self.symbols)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.order_by,
                ) {
                    __map.serialize_entry("orderBy", &self.order_by)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.sort) {
                    __map.serialize_entry("sort", &self.sort)?;
                }
                if self.include_sparklines {
                    __map
                        .serialize_entry("includeSparklines", &self.include_sparklines)?;
                }
                if !self.sparkline_intervals.is_empty() {
                    __map
                        .serialize_entry(
                            "sparklineIntervals",
                            &::buffa::json_helpers::EnumSeqJson(
                                &self.sparkline_intervals,
                            ),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListMarketOverviewRequestView<'a> {
            const PACKAGE: &'static str = "marketoverview.v1";
            const NAME: &'static str = "ListMarketOverviewRequest";
            const FULL_NAME: &'static str = "marketoverview.v1.ListMarketOverviewRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.ListMarketOverviewRequest";
        }
        ::buffa::impl_default_view_instance!(ListMarketOverviewRequestView);
        ::buffa::impl_view_reborrow!(ListMarketOverviewRequestView);
        /** Self-contained, `'static` owned view of a `ListMarketOverviewRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListMarketOverviewRequestView`]`<'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 [`ListMarketOverviewRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListMarketOverviewRequestOwnedView(
            ::buffa::OwnedView<ListMarketOverviewRequestView<'static>>,
        );
        impl ListMarketOverviewRequestOwnedView {
            /// 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(
                    ListMarketOverviewRequestOwnedView(
                        ::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(
                    ListMarketOverviewRequestOwnedView(
                        ::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::ListMarketOverviewRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListMarketOverviewRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`ListMarketOverviewRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListMarketOverviewRequestView<'_> {
                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::ListMarketOverviewRequest,
                ::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()
            }
            /// Filter by specific symbols; when empty, returns all enabled markets.
            ///
            /// Field 1: `symbols`
            #[must_use]
            pub fn symbols(&self) -> &::buffa::RepeatedView<'_, &'_ str> {
                &self.0.reborrow().symbols
            }
            /// Maximum number of markets to return. Defaults to 50 when omitted; maximum
            /// is 2000.
            ///
            /// Field 2: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbols, sort key, and sort direction. Sparkline options affect
            /// only response enrichment and may change between pages.
            ///
            /// Field 3: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
            /// Sort key. When unset/UNSPECIFIED, defaults to 24h quote volume.
            ///
            /// Field 4: `order_by`
            #[must_use]
            pub fn order_by(&self) -> ::buffa::EnumValue<super::super::MarketOrderBy> {
                self.0.reborrow().order_by
            }
            /// Sort direction (DESC=newest/highest first).
            ///
            /// Field 5: `sort`
            #[must_use]
            pub fn sort(&self) -> ::buffa::EnumValue<super::super::SortDirection> {
                self.0.reborrow().sort
            }
            /// When true, include sparklines in each MarketOverview.
            ///
            /// Field 6: `include_sparklines`
            #[must_use]
            pub fn include_sparklines(&self) -> bool {
                self.0.reborrow().include_sparklines
            }
            /// Which sparklines to include. If empty and include_sparklines is true,
            /// server defaults to 24h.
            ///
            /// Field 7: `sparkline_intervals`
            #[must_use]
            pub fn sparkline_intervals(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                ::buffa::EnumValue<super::super::SparklineInterval>,
            > {
                &self.0.reborrow().sparkline_intervals
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<ListMarketOverviewRequestView<'static>>,
        > for ListMarketOverviewRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListMarketOverviewRequestView<'static>>,
            ) -> Self {
                ListMarketOverviewRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListMarketOverviewRequestOwnedView>
        for ::buffa::OwnedView<ListMarketOverviewRequestView<'static>> {
            fn from(wrapper: ListMarketOverviewRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListMarketOverviewRequestView<'static>>,
        > for ListMarketOverviewRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<ListMarketOverviewRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListMarketOverviewRequest {
            type View<'a> = ListMarketOverviewRequestView<'a>;
            type ViewHandle = ListMarketOverviewRequestOwnedView;
        }
        impl ::serde::Serialize for ListMarketOverviewRequestOwnedView {
            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 ListMarketOverviewResponseView<'a> {
            /// Market overview rows for the requested page.
            ///
            /// Field 1: `markets`
            pub markets: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::MarketOverviewView<'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 ListMarketOverviewResponseView<'a> {
            type Owned = super::super::ListMarketOverviewResponse;
            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.markets
                            .push(
                                <super::super::__buffa::view::MarketOverviewView 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::ListMarketOverviewResponse,
                ::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::ListMarketOverviewResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListMarketOverviewResponse {
                    markets: self
                        .markets
                        .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 ListMarketOverviewResponseView<'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.markets {
                    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.markets {
                    ::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 ListMarketOverviewResponseView<'__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.markets.is_empty() {
                    __map.serialize_entry("markets", &*self.markets)?;
                }
                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 ListMarketOverviewResponseView<'a> {
            const PACKAGE: &'static str = "marketoverview.v1";
            const NAME: &'static str = "ListMarketOverviewResponse";
            const FULL_NAME: &'static str = "marketoverview.v1.ListMarketOverviewResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.ListMarketOverviewResponse";
        }
        ::buffa::impl_default_view_instance!(ListMarketOverviewResponseView);
        ::buffa::impl_view_reborrow!(ListMarketOverviewResponseView);
        /** Self-contained, `'static` owned view of a `ListMarketOverviewResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListMarketOverviewResponseView`]`<'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 [`ListMarketOverviewResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListMarketOverviewResponseOwnedView(
            ::buffa::OwnedView<ListMarketOverviewResponseView<'static>>,
        );
        impl ListMarketOverviewResponseOwnedView {
            /// 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(
                    ListMarketOverviewResponseOwnedView(
                        ::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(
                    ListMarketOverviewResponseOwnedView(
                        ::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::ListMarketOverviewResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListMarketOverviewResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`ListMarketOverviewResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListMarketOverviewResponseView<'_> {
                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::ListMarketOverviewResponse,
                ::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()
            }
            /// Market overview rows for the requested page.
            ///
            /// Field 1: `markets`
            #[must_use]
            pub fn markets(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::MarketOverviewView<'_>,
            > {
                &self.0.reborrow().markets
            }
            /// 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<ListMarketOverviewResponseView<'static>>,
        > for ListMarketOverviewResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListMarketOverviewResponseView<'static>>,
            ) -> Self {
                ListMarketOverviewResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListMarketOverviewResponseOwnedView>
        for ::buffa::OwnedView<ListMarketOverviewResponseView<'static>> {
            fn from(wrapper: ListMarketOverviewResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListMarketOverviewResponseView<'static>>,
        > for ListMarketOverviewResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<ListMarketOverviewResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListMarketOverviewResponse {
            type View<'a> = ListMarketOverviewResponseView<'a>;
            type ViewHandle = ListMarketOverviewResponseOwnedView;
        }
        impl ::serde::Serialize for ListMarketOverviewResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// MarketOverviewBatch is a websocket payload carrying batched market overview
        /// updates. It is published to a single all-markets channel at a fixed cadence.
        #[derive(Clone, Debug, Default)]
        pub struct MarketOverviewBatchView<'a> {
            /// Market overviews included in this batch.
            ///
            /// Field 1: `markets`
            pub markets: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::MarketOverviewView<'a>,
            >,
            /// Batch publish timestamp in nanoseconds since epoch.
            ///
            /// Field 2: `ts_ns`
            pub ts_ns: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for MarketOverviewBatchView<'a> {
            type Owned = super::super::MarketOverviewBatch;
            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::Varint,
                        )?;
                        view.ts_ns = ::buffa::types::decode_uint64(&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.markets
                            .push(
                                <super::super::__buffa::view::MarketOverviewView 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::MarketOverviewBatch,
                ::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::MarketOverviewBatch,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::MarketOverviewBatch {
                    markets: self
                        .markets
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    ts_ns: self.ts_ns,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for MarketOverviewBatchView<'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.markets {
                    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.ts_ns != 0u64 {
                    size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_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 _;
                for v in &self.markets {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if self.ts_ns != 0u64 {
                    ::buffa::types::put_uint64_field(2u32, self.ts_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 MarketOverviewBatchView<'__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.markets.is_empty() {
                    __map.serialize_entry("markets", &*self.markets)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_ns) {
                    __map
                        .serialize_entry(
                            "tsNs",
                            &::buffa::json_helpers::ProtoJson(&self.ts_ns),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for MarketOverviewBatchView<'a> {
            const PACKAGE: &'static str = "marketoverview.v1";
            const NAME: &'static str = "MarketOverviewBatch";
            const FULL_NAME: &'static str = "marketoverview.v1.MarketOverviewBatch";
            const TYPE_URL: &'static str = "type.googleapis.com/marketoverview.v1.MarketOverviewBatch";
        }
        ::buffa::impl_default_view_instance!(MarketOverviewBatchView);
        ::buffa::impl_view_reborrow!(MarketOverviewBatchView);
        /** Self-contained, `'static` owned view of a `MarketOverviewBatch` message.

 Wraps [`::buffa::OwnedView`]`<`[`MarketOverviewBatchView`]`<'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 [`MarketOverviewBatchView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct MarketOverviewBatchOwnedView(
            ::buffa::OwnedView<MarketOverviewBatchView<'static>>,
        );
        impl MarketOverviewBatchOwnedView {
            /// 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(
                    MarketOverviewBatchOwnedView(::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(
                    MarketOverviewBatchOwnedView(
                        ::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::MarketOverviewBatch,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    MarketOverviewBatchOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`MarketOverviewBatchView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &MarketOverviewBatchView<'_> {
                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::MarketOverviewBatch,
                ::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()
            }
            /// Market overviews included in this batch.
            ///
            /// Field 1: `markets`
            #[must_use]
            pub fn markets(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::MarketOverviewView<'_>,
            > {
                &self.0.reborrow().markets
            }
            /// Batch publish timestamp in nanoseconds since epoch.
            ///
            /// Field 2: `ts_ns`
            #[must_use]
            pub fn ts_ns(&self) -> u64 {
                self.0.reborrow().ts_ns
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<MarketOverviewBatchView<'static>>>
        for MarketOverviewBatchOwnedView {
            fn from(
                inner: ::buffa::OwnedView<MarketOverviewBatchView<'static>>,
            ) -> Self {
                MarketOverviewBatchOwnedView(inner)
            }
        }
        impl ::core::convert::From<MarketOverviewBatchOwnedView>
        for ::buffa::OwnedView<MarketOverviewBatchView<'static>> {
            fn from(wrapper: MarketOverviewBatchOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<MarketOverviewBatchView<'static>>>
        for MarketOverviewBatchOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<MarketOverviewBatchView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::MarketOverviewBatch {
            type View<'a> = MarketOverviewBatchView<'a>;
            type ViewHandle = MarketOverviewBatchOwnedView;
        }
        impl ::serde::Serialize for MarketOverviewBatchOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
    }
    /// Register this package's `Any` type entries and extension entries.
    pub fn register_types(reg: &mut ::buffa::type_registry::TypeRegistry) {
        reg.register_json_any(super::__ERROR_DETAIL_JSON_ANY);
        reg.register_json_any(super::__SPARKLINE_JSON_ANY);
        reg.register_json_any(super::__MARKET_OVERVIEW_JSON_ANY);
        reg.register_json_any(super::__LIST_MARKET_OVERVIEW_REQUEST_JSON_ANY);
        reg.register_json_any(super::__LIST_MARKET_OVERVIEW_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__MARKET_OVERVIEW_BATCH_JSON_ANY);
    }
}
#[doc(inline)]
pub use self::__buffa::view::ErrorDetailView;
#[doc(inline)]
pub use self::__buffa::view::ErrorDetailOwnedView;
#[doc(inline)]
pub use self::__buffa::view::SparklineView;
#[doc(inline)]
pub use self::__buffa::view::SparklineOwnedView;
#[doc(inline)]
pub use self::__buffa::view::MarketOverviewView;
#[doc(inline)]
pub use self::__buffa::view::MarketOverviewOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListMarketOverviewRequestView;
#[doc(inline)]
pub use self::__buffa::view::ListMarketOverviewRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListMarketOverviewResponseView;
#[doc(inline)]
pub use self::__buffa::view::ListMarketOverviewResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::MarketOverviewBatchView;
#[doc(inline)]
pub use self::__buffa::view::MarketOverviewBatchOwnedView;
#[doc(inline)]
pub use self::__buffa::register_types;