polyester/gen/buffa/

marketdata.v1.rs

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

/// HeatmapInterval controls bucket resolution for historical orderbook heatmap.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum HeatmapInterval {
    INTERVAL_UNSPECIFIED = 0i32,
    INTERVAL_1S = 1i32,
    INTERVAL_1M = 2i32,
    INTERVAL_5M = 3i32,
    INTERVAL_1H = 4i32,
}
impl HeatmapInterval {
    ///Idiomatic alias for [`Self::INTERVAL_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const IntervalUnspecified: Self = Self::INTERVAL_UNSPECIFIED;
    ///Idiomatic alias for [`Self::INTERVAL_1S`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Interval1s: Self = Self::INTERVAL_1S;
    ///Idiomatic alias for [`Self::INTERVAL_1M`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Interval1m: Self = Self::INTERVAL_1M;
    ///Idiomatic alias for [`Self::INTERVAL_5M`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Interval5m: Self = Self::INTERVAL_5M;
    ///Idiomatic alias for [`Self::INTERVAL_1H`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Interval1h: Self = Self::INTERVAL_1H;
}
impl ::core::default::Default for HeatmapInterval {
    fn default() -> Self {
        Self::INTERVAL_UNSPECIFIED
    }
}
impl ::serde::Serialize for HeatmapInterval {
    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 HeatmapInterval {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = HeatmapInterval;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(HeatmapInterval)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<HeatmapInterval, E> {
                <HeatmapInterval 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<HeatmapInterval, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapInterval 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<HeatmapInterval, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapInterval 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<HeatmapInterval, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for HeatmapInterval {
    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 HeatmapInterval {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::INTERVAL_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::INTERVAL_1S),
            2i32 => ::core::option::Option::Some(Self::INTERVAL_1M),
            3i32 => ::core::option::Option::Some(Self::INTERVAL_5M),
            4i32 => ::core::option::Option::Some(Self::INTERVAL_1H),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::INTERVAL_UNSPECIFIED => "INTERVAL_UNSPECIFIED",
            Self::INTERVAL_1S => "INTERVAL_1S",
            Self::INTERVAL_1M => "INTERVAL_1M",
            Self::INTERVAL_5M => "INTERVAL_5M",
            Self::INTERVAL_1H => "INTERVAL_1H",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "INTERVAL_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::INTERVAL_UNSPECIFIED)
            }
            "INTERVAL_1S" => ::core::option::Option::Some(Self::INTERVAL_1S),
            "INTERVAL_1M" => ::core::option::Option::Some(Self::INTERVAL_1M),
            "INTERVAL_5M" => ::core::option::Option::Some(Self::INTERVAL_5M),
            "INTERVAL_1H" => ::core::option::Option::Some(Self::INTERVAL_1H),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::INTERVAL_UNSPECIFIED,
            Self::INTERVAL_1S,
            Self::INTERVAL_1M,
            Self::INTERVAL_5M,
            Self::INTERVAL_1H,
        ]
    }
}
/// HeatmapDepth controls top-N levels included per side in each heatmap bucket.
///
/// Values intentionally mirror orderbook.v1.Depth for FE ergonomics, while
/// keeping this contract decoupled from orderbook service protos.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum HeatmapDepth {
    DEPTH_UNSPECIFIED = 0i32,
    DEPTH_1 = 1i32,
    DEPTH_5 = 2i32,
    DEPTH_10 = 3i32,
    DEPTH_20 = 4i32,
    DEPTH_50 = 5i32,
    DEPTH_100 = 6i32,
    DEPTH_200 = 7i32,
    DEPTH_500 = 8i32,
    DEPTH_1000 = 9i32,
}
impl HeatmapDepth {
    ///Idiomatic alias for [`Self::DEPTH_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const DepthUnspecified: Self = Self::DEPTH_UNSPECIFIED;
    ///Idiomatic alias for [`Self::DEPTH_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth1: Self = Self::DEPTH_1;
    ///Idiomatic alias for [`Self::DEPTH_5`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth5: Self = Self::DEPTH_5;
    ///Idiomatic alias for [`Self::DEPTH_10`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth10: Self = Self::DEPTH_10;
    ///Idiomatic alias for [`Self::DEPTH_20`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth20: Self = Self::DEPTH_20;
    ///Idiomatic alias for [`Self::DEPTH_50`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth50: Self = Self::DEPTH_50;
    ///Idiomatic alias for [`Self::DEPTH_100`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth100: Self = Self::DEPTH_100;
    ///Idiomatic alias for [`Self::DEPTH_200`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth200: Self = Self::DEPTH_200;
    ///Idiomatic alias for [`Self::DEPTH_500`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth500: Self = Self::DEPTH_500;
    ///Idiomatic alias for [`Self::DEPTH_1000`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Depth1000: Self = Self::DEPTH_1000;
}
impl ::core::default::Default for HeatmapDepth {
    fn default() -> Self {
        Self::DEPTH_UNSPECIFIED
    }
}
impl ::serde::Serialize for HeatmapDepth {
    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 HeatmapDepth {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = HeatmapDepth;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(HeatmapDepth)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<HeatmapDepth, E> {
                <HeatmapDepth 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<HeatmapDepth, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapDepth 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<HeatmapDepth, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapDepth 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<HeatmapDepth, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for HeatmapDepth {
    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 HeatmapDepth {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::DEPTH_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::DEPTH_1),
            2i32 => ::core::option::Option::Some(Self::DEPTH_5),
            3i32 => ::core::option::Option::Some(Self::DEPTH_10),
            4i32 => ::core::option::Option::Some(Self::DEPTH_20),
            5i32 => ::core::option::Option::Some(Self::DEPTH_50),
            6i32 => ::core::option::Option::Some(Self::DEPTH_100),
            7i32 => ::core::option::Option::Some(Self::DEPTH_200),
            8i32 => ::core::option::Option::Some(Self::DEPTH_500),
            9i32 => ::core::option::Option::Some(Self::DEPTH_1000),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::DEPTH_UNSPECIFIED => "DEPTH_UNSPECIFIED",
            Self::DEPTH_1 => "DEPTH_1",
            Self::DEPTH_5 => "DEPTH_5",
            Self::DEPTH_10 => "DEPTH_10",
            Self::DEPTH_20 => "DEPTH_20",
            Self::DEPTH_50 => "DEPTH_50",
            Self::DEPTH_100 => "DEPTH_100",
            Self::DEPTH_200 => "DEPTH_200",
            Self::DEPTH_500 => "DEPTH_500",
            Self::DEPTH_1000 => "DEPTH_1000",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "DEPTH_UNSPECIFIED" => ::core::option::Option::Some(Self::DEPTH_UNSPECIFIED),
            "DEPTH_1" => ::core::option::Option::Some(Self::DEPTH_1),
            "DEPTH_5" => ::core::option::Option::Some(Self::DEPTH_5),
            "DEPTH_10" => ::core::option::Option::Some(Self::DEPTH_10),
            "DEPTH_20" => ::core::option::Option::Some(Self::DEPTH_20),
            "DEPTH_50" => ::core::option::Option::Some(Self::DEPTH_50),
            "DEPTH_100" => ::core::option::Option::Some(Self::DEPTH_100),
            "DEPTH_200" => ::core::option::Option::Some(Self::DEPTH_200),
            "DEPTH_500" => ::core::option::Option::Some(Self::DEPTH_500),
            "DEPTH_1000" => ::core::option::Option::Some(Self::DEPTH_1000),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::DEPTH_UNSPECIFIED,
            Self::DEPTH_1,
            Self::DEPTH_5,
            Self::DEPTH_10,
            Self::DEPTH_20,
            Self::DEPTH_50,
            Self::DEPTH_100,
            Self::DEPTH_200,
            Self::DEPTH_500,
            Self::DEPTH_1000,
        ]
    }
}
/// HeatmapQuantityMode controls what qty_scaled means in returned levels.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum HeatmapQuantityMode {
    QTY_MODE_UNSPECIFIED = 0i32,
    CLOSE = 1i32,
    PEAK = 2i32,
}
impl HeatmapQuantityMode {
    ///Idiomatic alias for [`Self::QTY_MODE_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const QtyModeUnspecified: Self = Self::QTY_MODE_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CLOSE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Close: Self = Self::CLOSE;
    ///Idiomatic alias for [`Self::PEAK`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Peak: Self = Self::PEAK;
}
impl ::core::default::Default for HeatmapQuantityMode {
    fn default() -> Self {
        Self::QTY_MODE_UNSPECIFIED
    }
}
impl ::serde::Serialize for HeatmapQuantityMode {
    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 HeatmapQuantityMode {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = HeatmapQuantityMode;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ",
                        stringify!(HeatmapQuantityMode)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<HeatmapQuantityMode, E> {
                <HeatmapQuantityMode 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<HeatmapQuantityMode, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapQuantityMode 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<HeatmapQuantityMode, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <HeatmapQuantityMode 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<HeatmapQuantityMode, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for HeatmapQuantityMode {
    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 HeatmapQuantityMode {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::QTY_MODE_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::CLOSE),
            2i32 => ::core::option::Option::Some(Self::PEAK),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::QTY_MODE_UNSPECIFIED => "QTY_MODE_UNSPECIFIED",
            Self::CLOSE => "CLOSE",
            Self::PEAK => "PEAK",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "QTY_MODE_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::QTY_MODE_UNSPECIFIED)
            }
            "CLOSE" => ::core::option::Option::Some(Self::CLOSE),
            "PEAK" => ::core::option::Option::Some(Self::PEAK),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::QTY_MODE_UNSPECIFIED, Self::CLOSE, Self::PEAK]
    }
}
/// HeatmapTimeRange selects historical buckets by \[start_time, end_time\] (UTC).
/// At least one bound is required.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapTimeRange {
    /// Inclusive lower bound in UTC. Omit to leave the lower bound open.
    ///
    /// Field 1: `start_time`
    #[serde(
        rename = "startTime",
        alias = "start_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub start_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Inclusive upper bound in UTC. Omit to leave the upper bound open.
    ///
    /// Field 2: `end_time`
    #[serde(
        rename = "endTime",
        alias = "end_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub end_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapTimeRange {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapTimeRange")
            .field("start_time", &self.start_time)
            .field("end_time", &self.end_time)
            .finish()
    }
}
impl HeatmapTimeRange {
    /// 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/marketdata.v1.HeatmapTimeRange";
}
::buffa::impl_default_instance!(HeatmapTimeRange);
impl ::buffa::MessageName for HeatmapTimeRange {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapTimeRange";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapTimeRange";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapTimeRange";
}
impl ::buffa::Message for HeatmapTimeRange {
    /// 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.start_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.start_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.end_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.end_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.start_time.is_set() {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            self.start_time.write_to(__cache, buf);
        }
        if self.end_time.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.end_time.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.start_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.end_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.start_time = ::buffa::MessageField::none();
        self.end_time = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapTimeRange {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapTimeRange";
    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 HeatmapTimeRange {
    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 __HEATMAP_TIME_RANGE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapTimeRange",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapTimeRange>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapTimeRange>,
    is_wkt: false,
};
/// GetOrderbookHeatmapRequest fetches historical heatmap buckets.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetOrderbookHeatmapRequest {
    /// 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,
    /// Heatmap bucket interval.
    ///
    /// Field 2: `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<HeatmapInterval>,
    /// Top-N levels per side included in each bucket.
    ///
    /// Field 3: `depth`
    #[serde(
        rename = "depth",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub depth: ::buffa::EnumValue<HeatmapDepth>,
    /// Absolute time range for the first page. Reuse the same request filters and
    /// pass page_token from the prior response to continue older buckets.
    ///
    /// Field 4: `time_range`
    #[serde(
        rename = "timeRange",
        alias = "time_range",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub time_range: ::buffa::MessageField<HeatmapTimeRange>,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to symbol, interval, depth, quantity mode, and the original time
    /// range.
    ///
    /// Field 5: `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,
    /// Maximum number of delta buckets returned (min 1, max 20000).
    /// This limit counts only `chain.deltas`; `chain.base_keyframe` is not counted.
    ///
    /// Field 6: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// Quantity mode used for qty_scaled in snapshot/delta levels:
    /// - CLOSE: end-of-bucket quantity
    /// - PEAK: intra-bucket peak quantity
    ///
    /// Field 7: `quantity_mode`
    #[serde(
        rename = "quantityMode",
        alias = "quantity_mode",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub quantity_mode: ::buffa::EnumValue<HeatmapQuantityMode>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetOrderbookHeatmapRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetOrderbookHeatmapRequest")
            .field("symbol_id", &self.symbol_id)
            .field("interval", &self.interval)
            .field("depth", &self.depth)
            .field("time_range", &self.time_range)
            .field("page_token", &self.page_token)
            .field("limit", &self.limit)
            .field("quantity_mode", &self.quantity_mode)
            .finish()
    }
}
impl GetOrderbookHeatmapRequest {
    /// 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/marketdata.v1.GetOrderbookHeatmapRequest";
}
::buffa::impl_default_instance!(GetOrderbookHeatmapRequest);
impl ::buffa::MessageName for GetOrderbookHeatmapRequest {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetOrderbookHeatmapRequest";
    const FULL_NAME: &'static str = "marketdata.v1.GetOrderbookHeatmapRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapRequest";
}
impl ::buffa::Message for GetOrderbookHeatmapRequest {
    /// 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;
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.depth.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.time_range.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.time_range.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) as u32;
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        {
            let val = self.depth.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(3u32, val, buf);
            }
        }
        if self.time_range.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.time_range.write_to(__cache, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(5u32, &self.page_token, buf);
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(6u32, self.limit, buf);
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(7u32, 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.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.interval = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.depth = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.time_range.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::buffa::types::decode_uint32(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quantity_mode = ::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.symbol_id = 0u32;
        self.interval = ::buffa::EnumValue::from(0);
        self.depth = ::buffa::EnumValue::from(0);
        self.time_range = ::buffa::MessageField::none();
        self.page_token.clear();
        self.limit = 0u32;
        self.quantity_mode = ::buffa::EnumValue::from(0);
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetOrderbookHeatmapRequest {
    const PROTO_FQN: &'static str = "marketdata.v1.GetOrderbookHeatmapRequest";
    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 GetOrderbookHeatmapRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_ORDERBOOK_HEATMAP_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetOrderbookHeatmapRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetOrderbookHeatmapRequest>,
    is_wkt: false,
};
/// HeatmapLevels represents one side of the orderbook for snapshots.
/// Arrays are aligned by index and prices are sorted ascending for both sides:
/// - price_ticks\[i\] \<-\> qty_scaled\[i\]
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapLevels {
    /// Price levels in quote units scaled by 1e6.
    ///
    /// Field 1: `price_ticks`
    #[serde(
        rename = "priceTicks",
        alias = "price_ticks",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub price_ticks: ::buffa::alloc::vec::Vec<i64>,
    /// Quantity at each price level according to quantity_mode, scaled by the
    /// pair's base_quantity_scale from GetSpotConfig.
    ///
    /// Field 2: `qty_scaled`
    #[serde(
        rename = "qtyScaled",
        alias = "qty_scaled",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub qty_scaled: ::buffa::alloc::vec::Vec<i64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapLevels {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapLevels")
            .field("price_ticks", &self.price_ticks)
            .field("qty_scaled", &self.qty_scaled)
            .finish()
    }
}
impl HeatmapLevels {
    /// 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/marketdata.v1.HeatmapLevels";
}
::buffa::impl_default_instance!(HeatmapLevels);
impl ::buffa::MessageName for HeatmapLevels {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapLevels";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapLevels";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapLevels";
}
impl ::buffa::Message for HeatmapLevels {
    /// 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.price_ticks.is_empty() {
            let payload: u32 = self
                .price_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;
        }
        if !self.qty_scaled.is_empty() {
            let payload: u32 = self
                .qty_scaled
                .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 _;
        if !self.price_ticks.is_empty() {
            let payload: u32 = self
                .price_ticks
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(1u32, payload, buf);
            for &v in &self.price_ticks {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.qty_scaled.is_empty() {
            let payload: u32 = self
                .qty_scaled
                .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.qty_scaled {
                ::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 => {
                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.price_ticks.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.price_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.price_ticks.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            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.qty_scaled.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.qty_scaled
                            .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.qty_scaled.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.price_ticks.clear();
        self.qty_scaled.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapLevels {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapLevels";
    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 HeatmapLevels {
    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 __HEATMAP_LEVELS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapLevels",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapLevels>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapLevels>,
    is_wkt: false,
};
/// HeatmapDeltaLevels represents sparse per-bucket level changes for one side.
/// Arrays are aligned by index and prices are sorted ascending for both sides:
/// - price_ticks\[i\] \<-\> qty_scaled\[i\]
/// Delete semantics: qty_scaled\[i\] = 0 means delete level at price_ticks\[i\].
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapDeltaLevels {
    /// Price levels in quote units scaled by 1e6.
    ///
    /// Field 1: `price_ticks`
    #[serde(
        rename = "priceTicks",
        alias = "price_ticks",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub price_ticks: ::buffa::alloc::vec::Vec<i64>,
    /// Quantity at each price level, scaled by the pair's base_quantity_scale from
    /// GetSpotConfig. A zero value deletes the level at the matching price_ticks
    /// index.
    ///
    /// Field 2: `qty_scaled`
    #[serde(
        rename = "qtyScaled",
        alias = "qty_scaled",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub qty_scaled: ::buffa::alloc::vec::Vec<i64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapDeltaLevels {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapDeltaLevels")
            .field("price_ticks", &self.price_ticks)
            .field("qty_scaled", &self.qty_scaled)
            .finish()
    }
}
impl HeatmapDeltaLevels {
    /// 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/marketdata.v1.HeatmapDeltaLevels";
}
::buffa::impl_default_instance!(HeatmapDeltaLevels);
impl ::buffa::MessageName for HeatmapDeltaLevels {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapDeltaLevels";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaLevels";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaLevels";
}
impl ::buffa::Message for HeatmapDeltaLevels {
    /// 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.price_ticks.is_empty() {
            let payload: u32 = self
                .price_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;
        }
        if !self.qty_scaled.is_empty() {
            let payload: u32 = self
                .qty_scaled
                .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 _;
        if !self.price_ticks.is_empty() {
            let payload: u32 = self
                .price_ticks
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(1u32, payload, buf);
            for &v in &self.price_ticks {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.qty_scaled.is_empty() {
            let payload: u32 = self
                .qty_scaled
                .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.qty_scaled {
                ::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 => {
                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.price_ticks.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.price_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.price_ticks.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            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.qty_scaled.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.qty_scaled
                            .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.qty_scaled.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.price_ticks.clear();
        self.qty_scaled.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapDeltaLevels {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapDeltaLevels";
    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 HeatmapDeltaLevels {
    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 __HEATMAP_DELTA_LEVELS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapDeltaLevels",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapDeltaLevels>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapDeltaLevels>,
    is_wkt: false,
};
/// HeatmapKeyframe is a full-book snapshot anchor.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapKeyframe {
    /// Snapshot timestamp (seconds since epoch, UTC).
    ///
    /// Field 1: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    /// Best bid price in quote units scaled by 1e6.
    ///
    /// Field 2: `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 ask price in quote units scaled by 1e6.
    ///
    /// Field 3: `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,
    /// Mid price in quote units scaled by 1e6.
    ///
    /// Field 4: `mid_ticks`
    #[serde(
        rename = "midTicks",
        alias = "mid_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub mid_ticks: i64,
    /// Complete bid-side levels at the snapshot.
    ///
    /// Field 5: `bids`
    #[serde(
        rename = "bids",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub bids: ::buffa::MessageField<HeatmapLevels>,
    /// Complete ask-side levels at the snapshot.
    ///
    /// Field 6: `asks`
    #[serde(
        rename = "asks",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub asks: ::buffa::MessageField<HeatmapLevels>,
    /// Monotonic order book sequence at the snapshot.
    ///
    /// Field 7: `book_seq`
    #[serde(
        rename = "bookSeq",
        alias = "book_seq",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub book_seq: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapKeyframe {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapKeyframe")
            .field("ts_sec", &self.ts_sec)
            .field("best_bid_ticks", &self.best_bid_ticks)
            .field("best_ask_ticks", &self.best_ask_ticks)
            .field("mid_ticks", &self.mid_ticks)
            .field("bids", &self.bids)
            .field("asks", &self.asks)
            .field("book_seq", &self.book_seq)
            .finish()
    }
}
impl HeatmapKeyframe {
    /// 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/marketdata.v1.HeatmapKeyframe";
}
::buffa::impl_default_instance!(HeatmapKeyframe);
impl ::buffa::MessageName for HeatmapKeyframe {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapKeyframe";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapKeyframe";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapKeyframe";
}
impl ::buffa::Message for HeatmapKeyframe {
    /// 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.ts_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
        }
        if self.best_bid_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.best_bid_ticks) as u32;
        }
        if self.best_ask_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.best_ask_ticks) as u32;
        }
        if self.mid_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.mid_ticks) as u32;
        }
        if self.bids.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.bids.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.asks.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.asks.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.book_seq != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.book_seq) 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.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
        }
        if self.best_bid_ticks != 0i64 {
            ::buffa::types::put_int64_field(2u32, self.best_bid_ticks, buf);
        }
        if self.best_ask_ticks != 0i64 {
            ::buffa::types::put_int64_field(3u32, self.best_ask_ticks, buf);
        }
        if self.mid_ticks != 0i64 {
            ::buffa::types::put_int64_field(4u32, self.mid_ticks, buf);
        }
        if self.bids.is_set() {
            ::buffa::types::put_len_delimited_header(5u32, __cache.consume_next(), buf);
            self.bids.write_to(__cache, buf);
        }
        if self.asks.is_set() {
            ::buffa::types::put_len_delimited_header(6u32, __cache.consume_next(), buf);
            self.asks.write_to(__cache, buf);
        }
        if self.book_seq != 0u64 {
            ::buffa::types::put_uint64_field(7u32, self.book_seq, 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.ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_bid_ticks = ::buffa::types::decode_int64(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.best_ask_ticks = ::buffa::types::decode_int64(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.mid_ticks = ::buffa::types::decode_int64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.bids.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.asks.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.book_seq = ::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.ts_sec = 0u64;
        self.best_bid_ticks = 0i64;
        self.best_ask_ticks = 0i64;
        self.mid_ticks = 0i64;
        self.bids = ::buffa::MessageField::none();
        self.asks = ::buffa::MessageField::none();
        self.book_seq = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapKeyframe {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapKeyframe";
    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 HeatmapKeyframe {
    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 __HEATMAP_KEYFRAME_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapKeyframe",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapKeyframe>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapKeyframe>,
    is_wkt: false,
};
/// HeatmapDeltaBucket is one sparse update bucket containing both sides.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapDeltaBucket {
    /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
    ///
    /// Field 1: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    /// Sparse bid-side level changes in this bucket.
    ///
    /// Field 2: `bids`
    #[serde(
        rename = "bids",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub bids: ::buffa::MessageField<HeatmapDeltaLevels>,
    /// Sparse ask-side level changes in this bucket.
    ///
    /// Field 3: `asks`
    #[serde(
        rename = "asks",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub asks: ::buffa::MessageField<HeatmapDeltaLevels>,
    /// Number of upstream L2 updates aggregated into this interval bucket.
    ///
    /// Field 4: `updates_in_bucket`
    #[serde(
        rename = "updatesInBucket",
        alias = "updates_in_bucket",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub updates_in_bucket: u32,
    /// Earliest monotonic order book sequence represented by this bucket.
    ///
    /// Field 5: `book_seq_start`
    #[serde(
        rename = "bookSeqStart",
        alias = "book_seq_start",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub book_seq_start: u64,
    /// Latest monotonic order book sequence represented by this bucket.
    ///
    /// Field 6: `book_seq_end`
    #[serde(
        rename = "bookSeqEnd",
        alias = "book_seq_end",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub book_seq_end: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapDeltaBucket {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapDeltaBucket")
            .field("ts_sec", &self.ts_sec)
            .field("bids", &self.bids)
            .field("asks", &self.asks)
            .field("updates_in_bucket", &self.updates_in_bucket)
            .field("book_seq_start", &self.book_seq_start)
            .field("book_seq_end", &self.book_seq_end)
            .finish()
    }
}
impl HeatmapDeltaBucket {
    /// 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/marketdata.v1.HeatmapDeltaBucket";
}
::buffa::impl_default_instance!(HeatmapDeltaBucket);
impl ::buffa::MessageName for HeatmapDeltaBucket {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapDeltaBucket";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaBucket";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaBucket";
}
impl ::buffa::Message for HeatmapDeltaBucket {
    /// 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.ts_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
        }
        if self.bids.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.bids.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.asks.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.asks.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.updates_in_bucket != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.updates_in_bucket) as u32;
        }
        if self.book_seq_start != 0u64 {
            size
                += 1u32 + ::buffa::types::uint64_encoded_len(self.book_seq_start) as u32;
        }
        if self.book_seq_end != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.book_seq_end) 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.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
        }
        if self.bids.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.bids.write_to(__cache, buf);
        }
        if self.asks.is_set() {
            ::buffa::types::put_len_delimited_header(3u32, __cache.consume_next(), buf);
            self.asks.write_to(__cache, buf);
        }
        if self.updates_in_bucket != 0u32 {
            ::buffa::types::put_uint32_field(4u32, self.updates_in_bucket, buf);
        }
        if self.book_seq_start != 0u64 {
            ::buffa::types::put_uint64_field(5u32, self.book_seq_start, buf);
        }
        if self.book_seq_end != 0u64 {
            ::buffa::types::put_uint64_field(6u32, self.book_seq_end, 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.ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.bids.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.asks.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.updates_in_bucket = ::buffa::types::decode_uint32(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.book_seq_start = ::buffa::types::decode_uint64(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.book_seq_end = ::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.ts_sec = 0u64;
        self.bids = ::buffa::MessageField::none();
        self.asks = ::buffa::MessageField::none();
        self.updates_in_bucket = 0u32;
        self.book_seq_start = 0u64;
        self.book_seq_end = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapDeltaBucket {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapDeltaBucket";
    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 HeatmapDeltaBucket {
    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 __HEATMAP_DELTA_BUCKET_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapDeltaBucket",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapDeltaBucket>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapDeltaBucket>,
    is_wkt: false,
};
/// HeatmapLiveBucket is the canonical live payload for real-time heatmap updates.
/// It represents the latest state of one bucket (open or finalized).
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapLiveBucket {
    /// 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,
    /// Bucket interval for this payload.
    ///
    /// Field 2: `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<HeatmapInterval>,
    /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
    ///
    /// Field 3: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    /// True when this bucket is finalized; false for provisional updates to an
    /// open bucket.
    ///
    /// Field 4: `is_final`
    #[serde(
        rename = "isFinal",
        alias = "is_final",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub is_final: bool,
    /// Sparse bid-side level changes represented by this bucket.
    ///
    /// Field 5: `bids`
    #[serde(
        rename = "bids",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub bids: ::buffa::MessageField<HeatmapDeltaLevels>,
    /// Sparse ask-side level changes represented by this bucket.
    ///
    /// Field 6: `asks`
    #[serde(
        rename = "asks",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub asks: ::buffa::MessageField<HeatmapDeltaLevels>,
    /// Number of upstream L2 updates aggregated into this interval bucket.
    ///
    /// Field 7: `updates_in_bucket`
    #[serde(
        rename = "updatesInBucket",
        alias = "updates_in_bucket",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub updates_in_bucket: u32,
    /// Earliest monotonic order book sequence represented by this bucket.
    ///
    /// Field 8: `book_seq_start`
    #[serde(
        rename = "bookSeqStart",
        alias = "book_seq_start",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub book_seq_start: u64,
    /// Latest monotonic order book sequence represented by this bucket.
    ///
    /// Field 9: `book_seq_end`
    #[serde(
        rename = "bookSeqEnd",
        alias = "book_seq_end",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub book_seq_end: u64,
    /// Quantity semantics for qty_scaled in bids and asks.
    ///
    /// Field 10: `quantity_mode`
    #[serde(
        rename = "quantityMode",
        alias = "quantity_mode",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub quantity_mode: ::buffa::EnumValue<HeatmapQuantityMode>,
    /// Effective bin stride for this symbol as a price delta in 1e-6 quote-unit
    /// ticks.
    ///
    /// Field 11: `effective_bin_ticks`
    #[serde(
        rename = "effectiveBinTicks",
        alias = "effective_bin_ticks",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub effective_bin_ticks: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapLiveBucket {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapLiveBucket")
            .field("symbol_id", &self.symbol_id)
            .field("interval", &self.interval)
            .field("ts_sec", &self.ts_sec)
            .field("is_final", &self.is_final)
            .field("bids", &self.bids)
            .field("asks", &self.asks)
            .field("updates_in_bucket", &self.updates_in_bucket)
            .field("book_seq_start", &self.book_seq_start)
            .field("book_seq_end", &self.book_seq_end)
            .field("quantity_mode", &self.quantity_mode)
            .field("effective_bin_ticks", &self.effective_bin_ticks)
            .finish()
    }
}
impl HeatmapLiveBucket {
    /// 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/marketdata.v1.HeatmapLiveBucket";
}
::buffa::impl_default_instance!(HeatmapLiveBucket);
impl ::buffa::MessageName for HeatmapLiveBucket {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapLiveBucket";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapLiveBucket";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapLiveBucket";
}
impl ::buffa::Message for HeatmapLiveBucket {
    /// 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;
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.ts_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
        }
        if self.is_final {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.bids.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.bids.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.asks.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.asks.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.updates_in_bucket != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.updates_in_bucket) as u32;
        }
        if self.book_seq_start != 0u64 {
            size
                += 1u32 + ::buffa::types::uint64_encoded_len(self.book_seq_start) as u32;
        }
        if self.book_seq_end != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.book_seq_end) as u32;
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.effective_bin_ticks != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.effective_bin_ticks)
                        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);
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if self.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(3u32, self.ts_sec, buf);
        }
        if self.is_final {
            ::buffa::types::put_bool_field(4u32, self.is_final, buf);
        }
        if self.bids.is_set() {
            ::buffa::types::put_len_delimited_header(5u32, __cache.consume_next(), buf);
            self.bids.write_to(__cache, buf);
        }
        if self.asks.is_set() {
            ::buffa::types::put_len_delimited_header(6u32, __cache.consume_next(), buf);
            self.asks.write_to(__cache, buf);
        }
        if self.updates_in_bucket != 0u32 {
            ::buffa::types::put_uint32_field(7u32, self.updates_in_bucket, buf);
        }
        if self.book_seq_start != 0u64 {
            ::buffa::types::put_uint64_field(8u32, self.book_seq_start, buf);
        }
        if self.book_seq_end != 0u64 {
            ::buffa::types::put_uint64_field(9u32, self.book_seq_end, buf);
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(10u32, val, buf);
            }
        }
        if self.effective_bin_ticks != 0u64 {
            ::buffa::types::put_uint64_field(11u32, self.effective_bin_ticks, 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::Varint,
                )?;
                self.interval = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_final = ::buffa::types::decode_bool(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.bids.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.asks.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.updates_in_bucket = ::buffa::types::decode_uint32(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.book_seq_start = ::buffa::types::decode_uint64(buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.book_seq_end = ::buffa::types::decode_uint64(buf)?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quantity_mode = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.effective_bin_ticks = ::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.interval = ::buffa::EnumValue::from(0);
        self.ts_sec = 0u64;
        self.is_final = false;
        self.bids = ::buffa::MessageField::none();
        self.asks = ::buffa::MessageField::none();
        self.updates_in_bucket = 0u32;
        self.book_seq_start = 0u64;
        self.book_seq_end = 0u64;
        self.quantity_mode = ::buffa::EnumValue::from(0);
        self.effective_bin_ticks = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapLiveBucket {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapLiveBucket";
    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 HeatmapLiveBucket {
    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 __HEATMAP_LIVE_BUCKET_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapLiveBucket",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapLiveBucket>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapLiveBucket>,
    is_wkt: false,
};
/// HeatmapDeltaChain is the historical payload for all intervals.
/// Reconstruct by applying deltas over base_keyframe.
/// Deltas are ordered oldest-first by ts_sec.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct HeatmapDeltaChain {
    /// Full-book snapshot from which to apply the returned deltas.
    ///
    /// Field 1: `base_keyframe`
    #[serde(
        rename = "baseKeyframe",
        alias = "base_keyframe",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub base_keyframe: ::buffa::MessageField<HeatmapKeyframe>,
    /// Sparse update buckets ordered oldest-first by timestamp.
    ///
    /// Field 2: `deltas`
    #[serde(
        rename = "deltas",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub deltas: ::buffa::alloc::vec::Vec<HeatmapDeltaBucket>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for HeatmapDeltaChain {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("HeatmapDeltaChain")
            .field("base_keyframe", &self.base_keyframe)
            .field("deltas", &self.deltas)
            .finish()
    }
}
impl HeatmapDeltaChain {
    /// 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/marketdata.v1.HeatmapDeltaChain";
}
::buffa::impl_default_instance!(HeatmapDeltaChain);
impl ::buffa::MessageName for HeatmapDeltaChain {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "HeatmapDeltaChain";
    const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaChain";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaChain";
}
impl ::buffa::Message for HeatmapDeltaChain {
    /// 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.base_keyframe.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.base_keyframe.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        for v in &self.deltas {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.base_keyframe.is_set() {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            self.base_keyframe.write_to(__cache, buf);
        }
        for v in &self.deltas {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.base_keyframe.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            2u32 => {
                ::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.deltas.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.base_keyframe = ::buffa::MessageField::none();
        self.deltas.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for HeatmapDeltaChain {
    const PROTO_FQN: &'static str = "marketdata.v1.HeatmapDeltaChain";
    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 HeatmapDeltaChain {
    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 __HEATMAP_DELTA_CHAIN_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.HeatmapDeltaChain",
    to_json: ::buffa::type_registry::any_to_json::<HeatmapDeltaChain>,
    from_json: ::buffa::type_registry::any_from_json::<HeatmapDeltaChain>,
    is_wkt: false,
};
/// GetOrderbookHeatmapResponse returns a historical replay chain plus optional
/// live bucket state for explicit realtime stitching.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetOrderbookHeatmapResponse {
    /// Numeric spot market identifier returned for the requested market.
    ///
    /// 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,
    /// Bucket interval used for the returned chain.
    ///
    /// Field 2: `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<HeatmapInterval>,
    /// Top-N depth requested per side.
    ///
    /// Field 3: `depth`
    #[serde(
        rename = "depth",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub depth: ::buffa::EnumValue<HeatmapDepth>,
    /// Always returned as snapshot + sparse deltas for the requested interval.
    ///
    /// Field 4: `chain`
    #[serde(
        rename = "chain",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub chain: ::buffa::MessageField<HeatmapDeltaChain>,
    /// Latest finalized historical bucket timestamp in seconds since epoch (UTC).
    ///
    /// Field 5: `last_persisted_ts_sec`
    #[serde(
        rename = "lastPersistedTsSec",
        alias = "last_persisted_ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub last_persisted_ts_sec: u64,
    /// Book sequence anchor for realtime continuation; apply live updates where book_seq_end is greater than this value.
    ///
    /// Field 6: `live_from_book_seq_end`
    #[serde(
        rename = "liveFromBookSeqEnd",
        alias = "live_from_book_seq_end",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub live_from_book_seq_end: u64,
    /// True when live_from_book_seq_end is available and can be used as a realtime continuation anchor.
    ///
    /// Field 7: `has_live_anchor`
    #[serde(
        rename = "hasLiveAnchor",
        alias = "has_live_anchor",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub has_live_anchor: bool,
    /// Opaque cursor for the next page. Empty when no more results exist.
    ///
    /// Field 8: `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,
    /// Server response time in seconds since epoch (UTC).
    ///
    /// Field 10: `server_time_sec`
    #[serde(
        rename = "serverTimeSec",
        alias = "server_time_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub server_time_sec: u64,
    /// Quantity mode used for all qty_scaled values in the response.
    ///
    /// Field 11: `quantity_mode`
    #[serde(
        rename = "quantityMode",
        alias = "quantity_mode",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub quantity_mode: ::buffa::EnumValue<HeatmapQuantityMode>,
    /// Optional latest live bucket for the requested interval and depth.
    /// Present only when it is newer than the historical anchor and its quantity semantics match quantity_mode.
    ///
    /// Field 12: `live_bucket`
    #[serde(
        rename = "liveBucket",
        alias = "live_bucket",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub live_bucket: ::buffa::MessageField<HeatmapLiveBucket>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetOrderbookHeatmapResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetOrderbookHeatmapResponse")
            .field("symbol_id", &self.symbol_id)
            .field("interval", &self.interval)
            .field("depth", &self.depth)
            .field("chain", &self.chain)
            .field("last_persisted_ts_sec", &self.last_persisted_ts_sec)
            .field("live_from_book_seq_end", &self.live_from_book_seq_end)
            .field("has_live_anchor", &self.has_live_anchor)
            .field("next_page_token", &self.next_page_token)
            .field("server_time_sec", &self.server_time_sec)
            .field("quantity_mode", &self.quantity_mode)
            .field("live_bucket", &self.live_bucket)
            .finish()
    }
}
impl GetOrderbookHeatmapResponse {
    /// 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/marketdata.v1.GetOrderbookHeatmapResponse";
}
::buffa::impl_default_instance!(GetOrderbookHeatmapResponse);
impl ::buffa::MessageName for GetOrderbookHeatmapResponse {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetOrderbookHeatmapResponse";
    const FULL_NAME: &'static str = "marketdata.v1.GetOrderbookHeatmapResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapResponse";
}
impl ::buffa::Message for GetOrderbookHeatmapResponse {
    /// 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;
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.depth.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.chain.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.chain.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.last_persisted_ts_sec != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.last_persisted_ts_sec)
                        as u32;
        }
        if self.live_from_book_seq_end != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.live_from_book_seq_end)
                        as u32;
        }
        if self.has_live_anchor {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.next_page_token.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.next_page_token) as u32;
        }
        if self.server_time_sec != 0u64 {
            size
                += 1u32
                    + ::buffa::types::uint64_encoded_len(self.server_time_sec) as u32;
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.live_bucket.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.live_bucket.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.interval.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        {
            let val = self.depth.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(3u32, val, buf);
            }
        }
        if self.chain.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.chain.write_to(__cache, buf);
        }
        if self.last_persisted_ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(5u32, self.last_persisted_ts_sec, buf);
        }
        if self.live_from_book_seq_end != 0u64 {
            ::buffa::types::put_uint64_field(6u32, self.live_from_book_seq_end, buf);
        }
        if self.has_live_anchor {
            ::buffa::types::put_bool_field(7u32, self.has_live_anchor, buf);
        }
        if !self.next_page_token.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.next_page_token, buf);
        }
        if self.server_time_sec != 0u64 {
            ::buffa::types::put_uint64_field(10u32, self.server_time_sec, buf);
        }
        {
            let val = self.quantity_mode.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(11u32, val, buf);
            }
        }
        if self.live_bucket.is_set() {
            ::buffa::types::put_len_delimited_header(12u32, __cache.consume_next(), buf);
            self.live_bucket.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.interval = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.depth = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.chain.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.last_persisted_ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.live_from_book_seq_end = ::buffa::types::decode_uint64(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.has_live_anchor = ::buffa::types::decode_bool(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.next_page_token, buf)?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.server_time_sec = ::buffa::types::decode_uint64(buf)?;
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quantity_mode = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.live_bucket.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.symbol_id = 0u32;
        self.interval = ::buffa::EnumValue::from(0);
        self.depth = ::buffa::EnumValue::from(0);
        self.chain = ::buffa::MessageField::none();
        self.last_persisted_ts_sec = 0u64;
        self.live_from_book_seq_end = 0u64;
        self.has_live_anchor = false;
        self.next_page_token.clear();
        self.server_time_sec = 0u64;
        self.quantity_mode = ::buffa::EnumValue::from(0);
        self.live_bucket = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetOrderbookHeatmapResponse {
    const PROTO_FQN: &'static str = "marketdata.v1.GetOrderbookHeatmapResponse";
    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 GetOrderbookHeatmapResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_ORDERBOOK_HEATMAP_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetOrderbookHeatmapResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetOrderbookHeatmapResponse>,
    is_wkt: false,
};
/// SideFilter controls which aggressor side of trades to return.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum SideFilter {
    /// Return trades from both BUY and SELL aggressors.
    SIDE_UNSPECIFIED = 0i32,
    /// Return trades where the taker/aggressor was buying the base asset.
    BUY = 1i32,
    /// Return trades where the taker/aggressor was selling the base asset.
    SELL = 2i32,
}
impl SideFilter {
    ///Idiomatic alias for [`Self::SIDE_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SideUnspecified: Self = Self::SIDE_UNSPECIFIED;
    ///Idiomatic alias for [`Self::BUY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Buy: Self = Self::BUY;
    ///Idiomatic alias for [`Self::SELL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sell: Self = Self::SELL;
}
impl ::core::default::Default for SideFilter {
    fn default() -> Self {
        Self::SIDE_UNSPECIFIED
    }
}
impl ::serde::Serialize for SideFilter {
    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 SideFilter {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = SideFilter;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(SideFilter)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<SideFilter, E> {
                <SideFilter 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<SideFilter, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SideFilter 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<SideFilter, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <SideFilter 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<SideFilter, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for SideFilter {
    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 SideFilter {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::SIDE_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::BUY),
            2i32 => ::core::option::Option::Some(Self::SELL),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::SIDE_UNSPECIFIED => "SIDE_UNSPECIFIED",
            Self::BUY => "BUY",
            Self::SELL => "SELL",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "SIDE_UNSPECIFIED" => ::core::option::Option::Some(Self::SIDE_UNSPECIFIED),
            "BUY" => ::core::option::Option::Some(Self::BUY),
            "SELL" => ::core::option::Option::Some(Self::SELL),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::SIDE_UNSPECIFIED, Self::BUY, Self::SELL]
    }
}
/// Timeframe represents an OHLCV candle bucket.
///
/// Most values are fixed-duration buckets. `MONTH_1` is calendar-based (UTC
/// month boundaries).
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum Timeframe {
    TIMEFRAME_UNSPECIFIED = 0i32,
    /// 1 second
    SEC_1 = 1i32,
    /// 1 minute
    MIN_1 = 2i32,
    /// 5 minutes
    MIN_5 = 3i32,
    /// 15 minutes
    MIN_15 = 4i32,
    /// 30 minutes
    MIN_30 = 5i32,
    /// 1 hour
    HOUR_1 = 6i32,
    /// 4 hours
    HOUR_4 = 7i32,
    /// 1 day
    DAY_1 = 8i32,
    /// 12 hours
    HOUR_12 = 9i32,
    /// 1 week
    WEEK_1 = 10i32,
    /// 1 month (calendar month, UTC)
    MONTH_1 = 11i32,
}
impl Timeframe {
    ///Idiomatic alias for [`Self::TIMEFRAME_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const TimeframeUnspecified: Self = Self::TIMEFRAME_UNSPECIFIED;
    ///Idiomatic alias for [`Self::SEC_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Sec1: Self = Self::SEC_1;
    ///Idiomatic alias for [`Self::MIN_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Min1: Self = Self::MIN_1;
    ///Idiomatic alias for [`Self::MIN_5`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Min5: Self = Self::MIN_5;
    ///Idiomatic alias for [`Self::MIN_15`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Min15: Self = Self::MIN_15;
    ///Idiomatic alias for [`Self::MIN_30`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Min30: Self = Self::MIN_30;
    ///Idiomatic alias for [`Self::HOUR_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Hour1: Self = Self::HOUR_1;
    ///Idiomatic alias for [`Self::HOUR_4`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Hour4: Self = Self::HOUR_4;
    ///Idiomatic alias for [`Self::DAY_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Day1: Self = Self::DAY_1;
    ///Idiomatic alias for [`Self::HOUR_12`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Hour12: Self = Self::HOUR_12;
    ///Idiomatic alias for [`Self::WEEK_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Week1: Self = Self::WEEK_1;
    ///Idiomatic alias for [`Self::MONTH_1`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Month1: Self = Self::MONTH_1;
}
impl ::core::default::Default for Timeframe {
    fn default() -> Self {
        Self::TIMEFRAME_UNSPECIFIED
    }
}
impl ::serde::Serialize for Timeframe {
    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 Timeframe {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = Timeframe;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(Timeframe)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<Timeframe, E> {
                <Timeframe 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<Timeframe, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <Timeframe 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<Timeframe, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <Timeframe 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<Timeframe, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for Timeframe {
    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 Timeframe {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::TIMEFRAME_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::SEC_1),
            2i32 => ::core::option::Option::Some(Self::MIN_1),
            3i32 => ::core::option::Option::Some(Self::MIN_5),
            4i32 => ::core::option::Option::Some(Self::MIN_15),
            5i32 => ::core::option::Option::Some(Self::MIN_30),
            6i32 => ::core::option::Option::Some(Self::HOUR_1),
            7i32 => ::core::option::Option::Some(Self::HOUR_4),
            8i32 => ::core::option::Option::Some(Self::DAY_1),
            9i32 => ::core::option::Option::Some(Self::HOUR_12),
            10i32 => ::core::option::Option::Some(Self::WEEK_1),
            11i32 => ::core::option::Option::Some(Self::MONTH_1),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::TIMEFRAME_UNSPECIFIED => "TIMEFRAME_UNSPECIFIED",
            Self::SEC_1 => "SEC_1",
            Self::MIN_1 => "MIN_1",
            Self::MIN_5 => "MIN_5",
            Self::MIN_15 => "MIN_15",
            Self::MIN_30 => "MIN_30",
            Self::HOUR_1 => "HOUR_1",
            Self::HOUR_4 => "HOUR_4",
            Self::DAY_1 => "DAY_1",
            Self::HOUR_12 => "HOUR_12",
            Self::WEEK_1 => "WEEK_1",
            Self::MONTH_1 => "MONTH_1",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "TIMEFRAME_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::TIMEFRAME_UNSPECIFIED)
            }
            "SEC_1" => ::core::option::Option::Some(Self::SEC_1),
            "MIN_1" => ::core::option::Option::Some(Self::MIN_1),
            "MIN_5" => ::core::option::Option::Some(Self::MIN_5),
            "MIN_15" => ::core::option::Option::Some(Self::MIN_15),
            "MIN_30" => ::core::option::Option::Some(Self::MIN_30),
            "HOUR_1" => ::core::option::Option::Some(Self::HOUR_1),
            "HOUR_4" => ::core::option::Option::Some(Self::HOUR_4),
            "DAY_1" => ::core::option::Option::Some(Self::DAY_1),
            "HOUR_12" => ::core::option::Option::Some(Self::HOUR_12),
            "WEEK_1" => ::core::option::Option::Some(Self::WEEK_1),
            "MONTH_1" => ::core::option::Option::Some(Self::MONTH_1),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::TIMEFRAME_UNSPECIFIED,
            Self::SEC_1,
            Self::MIN_1,
            Self::MIN_5,
            Self::MIN_15,
            Self::MIN_30,
            Self::HOUR_1,
            Self::HOUR_4,
            Self::DAY_1,
            Self::HOUR_12,
            Self::WEEK_1,
            Self::MONTH_1,
        ]
    }
}
/// PairStatus describes which order mutations a spot pair currently accepts.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum PairStatus {
    /// Pair status was not provided.
    PAIR_STATUS_UNSPECIFIED = 0i32,
    /// New orders and cancellations are accepted.
    PAIR_STATUS_ENABLED = 1i32,
    /// New orders are temporarily disabled.
    PAIR_STATUS_DISABLED = 2i32,
    /// Only cancellations are accepted.
    PAIR_STATUS_CANCEL_ONLY = 3i32,
    /// New orders must use a post-only execution variant.
    PAIR_STATUS_POST_ONLY = 4i32,
    /// New spot orders are blocked by reduce-only policy.
    PAIR_STATUS_REDUCE_ONLY = 5i32,
}
impl PairStatus {
    ///Idiomatic alias for [`Self::PAIR_STATUS_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::PAIR_STATUS_UNSPECIFIED;
    ///Idiomatic alias for [`Self::PAIR_STATUS_ENABLED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Enabled: Self = Self::PAIR_STATUS_ENABLED;
    ///Idiomatic alias for [`Self::PAIR_STATUS_DISABLED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Disabled: Self = Self::PAIR_STATUS_DISABLED;
    ///Idiomatic alias for [`Self::PAIR_STATUS_CANCEL_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CancelOnly: Self = Self::PAIR_STATUS_CANCEL_ONLY;
    ///Idiomatic alias for [`Self::PAIR_STATUS_POST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PostOnly: Self = Self::PAIR_STATUS_POST_ONLY;
    ///Idiomatic alias for [`Self::PAIR_STATUS_REDUCE_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const ReduceOnly: Self = Self::PAIR_STATUS_REDUCE_ONLY;
}
impl ::core::default::Default for PairStatus {
    fn default() -> Self {
        Self::PAIR_STATUS_UNSPECIFIED
    }
}
impl ::serde::Serialize for PairStatus {
    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 PairStatus {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = PairStatus;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(PairStatus)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<PairStatus, E> {
                <PairStatus 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<PairStatus, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <PairStatus 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<PairStatus, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom(
                            ::buffa::alloc::format!("enum value {v} out of i32 range"),
                        )
                    })?;
                <PairStatus 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<PairStatus, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for PairStatus {
    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 PairStatus {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::PAIR_STATUS_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::PAIR_STATUS_ENABLED),
            2i32 => ::core::option::Option::Some(Self::PAIR_STATUS_DISABLED),
            3i32 => ::core::option::Option::Some(Self::PAIR_STATUS_CANCEL_ONLY),
            4i32 => ::core::option::Option::Some(Self::PAIR_STATUS_POST_ONLY),
            5i32 => ::core::option::Option::Some(Self::PAIR_STATUS_REDUCE_ONLY),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::PAIR_STATUS_UNSPECIFIED => "PAIR_STATUS_UNSPECIFIED",
            Self::PAIR_STATUS_ENABLED => "PAIR_STATUS_ENABLED",
            Self::PAIR_STATUS_DISABLED => "PAIR_STATUS_DISABLED",
            Self::PAIR_STATUS_CANCEL_ONLY => "PAIR_STATUS_CANCEL_ONLY",
            Self::PAIR_STATUS_POST_ONLY => "PAIR_STATUS_POST_ONLY",
            Self::PAIR_STATUS_REDUCE_ONLY => "PAIR_STATUS_REDUCE_ONLY",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "PAIR_STATUS_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_UNSPECIFIED)
            }
            "PAIR_STATUS_ENABLED" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_ENABLED)
            }
            "PAIR_STATUS_DISABLED" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_DISABLED)
            }
            "PAIR_STATUS_CANCEL_ONLY" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_CANCEL_ONLY)
            }
            "PAIR_STATUS_POST_ONLY" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_POST_ONLY)
            }
            "PAIR_STATUS_REDUCE_ONLY" => {
                ::core::option::Option::Some(Self::PAIR_STATUS_REDUCE_ONLY)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::PAIR_STATUS_UNSPECIFIED,
            Self::PAIR_STATUS_ENABLED,
            Self::PAIR_STATUS_DISABLED,
            Self::PAIR_STATUS_CANCEL_ONLY,
            Self::PAIR_STATUS_POST_ONLY,
            Self::PAIR_STATUS_REDUCE_ONLY,
        ]
    }
}
/// ---------------------------------------------------------------------------
/// GetTrades: Binary (protobuf) request/response with scaled integers.
/// REST responses expose decimal strings.
/// ---------------------------------------------------------------------------
///
/// GetTradesRequest selects recent public trades for one spot market.
///
/// Results are ordered newest-first by execution timestamp, with match_id as a
/// tie-breaker. When both start_time and end_time are set, both bounds are
/// inclusive.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetTradesRequest {
    /// Stable numeric pair id from GetSpotConfig.
    ///
    /// 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,
    /// Maximum number of trades to return. Defaults to 100 when unset; max 1000.
    ///
    /// Field 2: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// Inclusive lower bound for trade execution time. Must not be more than
    /// 5 minutes in the future.
    ///
    /// Field 3: `start_time`
    #[serde(
        rename = "startTime",
        alias = "start_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub start_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Inclusive upper bound for trade execution time. Must be greater than or
    /// equal to start_time when both are set, and must not be more than 5 minutes
    /// in the future.
    ///
    /// Field 4: `end_time`
    #[serde(
        rename = "endTime",
        alias = "end_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub end_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Optional filter by trade aggressor side. Unspecified returns both sides.
    ///
    /// Field 5: `side`
    #[serde(
        rename = "side",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub side: ::buffa::EnumValue<SideFilter>,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to symbol, time bounds, side filter, and newest-first sort order.
    ///
    /// Field 6: `page_token`
    #[serde(
        rename = "pageToken",
        alias = "page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetTradesRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetTradesRequest")
            .field("symbol_id", &self.symbol_id)
            .field("limit", &self.limit)
            .field("start_time", &self.start_time)
            .field("end_time", &self.end_time)
            .field("side", &self.side)
            .field("page_token", &self.page_token)
            .finish()
    }
}
impl GetTradesRequest {
    /// 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/marketdata.v1.GetTradesRequest";
}
::buffa::impl_default_instance!(GetTradesRequest);
impl ::buffa::MessageName for GetTradesRequest {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetTradesRequest";
    const FULL_NAME: &'static str = "marketdata.v1.GetTradesRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetTradesRequest";
}
impl ::buffa::Message for GetTradesRequest {
    /// 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.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if self.start_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.start_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.end_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.end_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        {
            let val = self.side.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.limit, buf);
        }
        if self.start_time.is_set() {
            ::buffa::types::put_len_delimited_header(3u32, __cache.consume_next(), buf);
            self.start_time.write_to(__cache, buf);
        }
        if self.end_time.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.end_time.write_to(__cache, buf);
        }
        {
            let val = self.side.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(5u32, val, buf);
            }
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(6u32, &self.page_token, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(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::Message::merge_length_delimited(
                    self.start_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.end_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.side = ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.symbol_id = 0u32;
        self.limit = 0u32;
        self.start_time = ::buffa::MessageField::none();
        self.end_time = ::buffa::MessageField::none();
        self.side = ::buffa::EnumValue::from(0);
        self.page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetTradesRequest {
    const PROTO_FQN: &'static str = "marketdata.v1.GetTradesRequest";
    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 GetTradesRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_TRADES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetTradesRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetTradesRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetTradesRequest>,
    is_wkt: false,
};
/// MarketTrade is one public trade print represented with scaled integers.
///
/// REST responses render price and quantity as decimal strings.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct MarketTrade {
    /// Stable numeric pair id from GetSpotConfig.
    ///
    /// 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,
    /// Stable trade id within the symbol, suitable for pagination and de-duplication.
    ///
    /// Field 2: `match_id`
    #[serde(
        rename = "matchId",
        alias = "match_id",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub match_id: u64,
    /// True when the taker/aggressor bought the base asset; false when the
    /// taker/aggressor sold the base asset.
    ///
    /// Field 3: `is_buy`
    #[serde(
        rename = "isBuy",
        alias = "is_buy",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub is_buy: bool,
    /// Trade price in quote-asset units scaled by 1e6.
    ///
    /// Field 4: `price_ticks`
    #[serde(
        rename = "priceTicks",
        alias = "price_ticks",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub price_ticks: i64,
    /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 5: `qty_scaled`
    #[serde(
        rename = "qtyScaled",
        alias = "qty_scaled",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub qty_scaled: i64,
    /// Trade execution timestamp, in nanoseconds since the Unix epoch (UTC).
    ///
    /// Field 6: `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 MarketTrade {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MarketTrade")
            .field("symbol_id", &self.symbol_id)
            .field("match_id", &self.match_id)
            .field("is_buy", &self.is_buy)
            .field("price_ticks", &self.price_ticks)
            .field("qty_scaled", &self.qty_scaled)
            .field("ts_ns", &self.ts_ns)
            .finish()
    }
}
impl MarketTrade {
    /// 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/marketdata.v1.MarketTrade";
}
::buffa::impl_default_instance!(MarketTrade);
impl ::buffa::MessageName for MarketTrade {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "MarketTrade";
    const FULL_NAME: &'static str = "marketdata.v1.MarketTrade";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.MarketTrade";
}
impl ::buffa::Message for MarketTrade {
    /// 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.match_id != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.match_id) as u32;
        }
        if self.is_buy {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.price_ticks != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.price_ticks) as u32;
        }
        if self.qty_scaled != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.qty_scaled) as u32;
        }
        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 _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        if self.match_id != 0u64 {
            ::buffa::types::put_uint64_field(2u32, self.match_id, buf);
        }
        if self.is_buy {
            ::buffa::types::put_bool_field(3u32, self.is_buy, buf);
        }
        if self.price_ticks != 0i64 {
            ::buffa::types::put_int64_field(4u32, self.price_ticks, buf);
        }
        if self.qty_scaled != 0i64 {
            ::buffa::types::put_int64_field(5u32, self.qty_scaled, buf);
        }
        if self.ts_ns != 0u64 {
            ::buffa::types::put_uint64_field(6u32, 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::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.match_id = ::buffa::types::decode_uint64(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_buy = ::buffa::types::decode_bool(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.price_ticks = ::buffa::types::decode_int64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.qty_scaled = ::buffa::types::decode_int64(buf)?;
            }
            6u32 => {
                ::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.symbol_id = 0u32;
        self.match_id = 0u64;
        self.is_buy = false;
        self.price_ticks = 0i64;
        self.qty_scaled = 0i64;
        self.ts_ns = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MarketTrade {
    const PROTO_FQN: &'static str = "marketdata.v1.MarketTrade";
    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 MarketTrade {
    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_TRADE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.MarketTrade",
    to_json: ::buffa::type_registry::any_to_json::<MarketTrade>,
    from_json: ::buffa::type_registry::any_from_json::<MarketTrade>,
    is_wkt: false,
};
/// GetTradesResponse contains public trades for one spot market.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetTradesResponse {
    /// Trades ordered newest-first by execution timestamp, with match_id as a
    /// tie-breaker.
    ///
    /// Field 1: `trades`
    #[serde(
        rename = "trades",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub trades: ::buffa::alloc::vec::Vec<MarketTrade>,
    /// 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 GetTradesResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetTradesResponse")
            .field("trades", &self.trades)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl GetTradesResponse {
    /// 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/marketdata.v1.GetTradesResponse";
}
::buffa::impl_default_instance!(GetTradesResponse);
impl ::buffa::MessageName for GetTradesResponse {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetTradesResponse";
    const FULL_NAME: &'static str = "marketdata.v1.GetTradesResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetTradesResponse";
}
impl ::buffa::Message for GetTradesResponse {
    /// 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.trades {
            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.trades {
            ::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.trades.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.trades.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetTradesResponse {
    const PROTO_FQN: &'static str = "marketdata.v1.GetTradesResponse";
    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 GetTradesResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_TRADES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetTradesResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetTradesResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetTradesResponse>,
    is_wkt: false,
};
/// ---------------------------------------------------------------------------
/// GetCandles: Binary (protobuf) request/response with scaled integers.
/// REST responses expose decimal strings.
/// ---------------------------------------------------------------------------
///
/// GetCandlesRequest selects a spot market candle series.
///
/// The response is ordered newest-first by candle bucket start time. When both
/// start_time and end_time are set, both bounds are inclusive.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetCandlesRequest {
    /// 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,
    /// Candle bucket size. Required for ConnectRPC clients.
    ///
    /// Field 2: `timeframe`
    #[serde(
        rename = "timeframe",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub timeframe: ::buffa::EnumValue<Timeframe>,
    /// Maximum number of closed candles to return. Defaults to 500 when unset;
    /// max 10000.
    ///
    /// Field 3: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
    /// Must not be more than 5 minutes in the future.
    ///
    /// Field 4: `start_time`
    #[serde(
        rename = "startTime",
        alias = "start_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub start_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
    /// Must be greater than or equal to start_time when both are set, and must not
    /// be more than 5 minutes in the future.
    ///
    /// Field 5: `end_time`
    #[serde(
        rename = "endTime",
        alias = "end_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub end_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Include the current open candle when it is available and inside the
    /// requested range.
    /// The open candle is prepended to the newest-first candle list and does not
    /// count toward the closed-candle limit.
    ///
    /// Field 6: `include_incomplete`
    #[serde(
        rename = "includeIncomplete",
        alias = "include_incomplete",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub include_incomplete: bool,
    /// Include the composite reference market candle series for the same market,
    /// timeframe, and time range.
    /// The reference series can be empty when no reference series is available for
    /// the requested timeframe.
    ///
    /// Field 7: `include_reference`
    #[serde(
        rename = "includeReference",
        alias = "include_reference",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub include_reference: bool,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to symbol, timeframe, time bounds, and newest-first candle ordering.
    /// Inclusion flags affect response enrichment and may change between pages.
    ///
    /// Field 8: `page_token`
    #[serde(
        rename = "pageToken",
        alias = "page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetCandlesRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetCandlesRequest")
            .field("symbol_id", &self.symbol_id)
            .field("timeframe", &self.timeframe)
            .field("limit", &self.limit)
            .field("start_time", &self.start_time)
            .field("end_time", &self.end_time)
            .field("include_incomplete", &self.include_incomplete)
            .field("include_reference", &self.include_reference)
            .field("page_token", &self.page_token)
            .finish()
    }
}
impl GetCandlesRequest {
    /// 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/marketdata.v1.GetCandlesRequest";
}
::buffa::impl_default_instance!(GetCandlesRequest);
impl ::buffa::MessageName for GetCandlesRequest {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetCandlesRequest";
    const FULL_NAME: &'static str = "marketdata.v1.GetCandlesRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesRequest";
}
impl ::buffa::Message for GetCandlesRequest {
    /// 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;
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if self.start_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.start_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.end_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.end_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.include_incomplete {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.include_reference {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.limit, buf);
        }
        if self.start_time.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.start_time.write_to(__cache, buf);
        }
        if self.end_time.is_set() {
            ::buffa::types::put_len_delimited_header(5u32, __cache.consume_next(), buf);
            self.end_time.write_to(__cache, buf);
        }
        if self.include_incomplete {
            ::buffa::types::put_bool_field(6u32, self.include_incomplete, buf);
        }
        if self.include_reference {
            ::buffa::types::put_bool_field(7u32, self.include_reference, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.page_token, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.timeframe = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::buffa::types::decode_uint32(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.start_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.end_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.include_incomplete = ::buffa::types::decode_bool(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.include_reference = ::buffa::types::decode_bool(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.symbol_id = 0u32;
        self.timeframe = ::buffa::EnumValue::from(0);
        self.limit = 0u32;
        self.start_time = ::buffa::MessageField::none();
        self.end_time = ::buffa::MessageField::none();
        self.include_incomplete = false;
        self.include_reference = false;
        self.page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetCandlesRequest {
    const PROTO_FQN: &'static str = "marketdata.v1.GetCandlesRequest";
    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 GetCandlesRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_CANDLES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetCandlesRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetCandlesRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetCandlesRequest>,
    is_wkt: false,
};
/// GetCandlesColumnsRequest selects a spot market candle series for columnar output.
///
/// The response is ordered oldest-first for efficient chart ingestion. When both
/// start_time and end_time are set, both bounds are inclusive.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetCandlesColumnsRequest {
    /// 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,
    /// Candle bucket size. Required for ConnectRPC clients.
    ///
    /// Field 2: `timeframe`
    #[serde(
        rename = "timeframe",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub timeframe: ::buffa::EnumValue<Timeframe>,
    /// Maximum number of closed candles to return. Defaults to 500 when unset;
    /// max 10000.
    ///
    /// Field 3: `limit`
    #[serde(
        rename = "limit",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub limit: u32,
    /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
    /// Must not be more than 5 minutes in the future.
    ///
    /// Field 4: `start_time`
    #[serde(
        rename = "startTime",
        alias = "start_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub start_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
    /// Must be greater than or equal to start_time when both are set, and must not
    /// be more than 5 minutes in the future.
    ///
    /// Field 5: `end_time`
    #[serde(
        rename = "endTime",
        alias = "end_time",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub end_time: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Include the current open candle when it is available and inside the
    /// requested range.
    /// The open candle is prepended to the newest-first candle list and does not
    /// count toward the closed-candle limit.
    ///
    /// Field 6: `include_incomplete`
    #[serde(
        rename = "includeIncomplete",
        alias = "include_incomplete",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub include_incomplete: bool,
    /// Include the composite reference market candle series for the same market,
    /// timeframe, and time range.
    /// The reference series can be empty when no reference series is available for
    /// the requested timeframe.
    ///
    /// Field 7: `include_reference`
    #[serde(
        rename = "includeReference",
        alias = "include_reference",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub include_reference: bool,
    /// Opaque keyset cursor from a previous response. The cursor is exclusive and
    /// bound to symbol, timeframe, time bounds, and oldest-first candle ordering.
    /// Inclusion flags and columnar response shape may change between pages.
    ///
    /// Field 8: `page_token`
    #[serde(
        rename = "pageToken",
        alias = "page_token",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub page_token: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetCandlesColumnsRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetCandlesColumnsRequest")
            .field("symbol_id", &self.symbol_id)
            .field("timeframe", &self.timeframe)
            .field("limit", &self.limit)
            .field("start_time", &self.start_time)
            .field("end_time", &self.end_time)
            .field("include_incomplete", &self.include_incomplete)
            .field("include_reference", &self.include_reference)
            .field("page_token", &self.page_token)
            .finish()
    }
}
impl GetCandlesColumnsRequest {
    /// 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/marketdata.v1.GetCandlesColumnsRequest";
}
::buffa::impl_default_instance!(GetCandlesColumnsRequest);
impl ::buffa::MessageName for GetCandlesColumnsRequest {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetCandlesColumnsRequest";
    const FULL_NAME: &'static str = "marketdata.v1.GetCandlesColumnsRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesColumnsRequest";
}
impl ::buffa::Message for GetCandlesColumnsRequest {
    /// 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;
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.limit != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
        }
        if self.start_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.start_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.end_time.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.end_time.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.include_incomplete {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.include_reference {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.page_token.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.page_token) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if self.limit != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.limit, buf);
        }
        if self.start_time.is_set() {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            self.start_time.write_to(__cache, buf);
        }
        if self.end_time.is_set() {
            ::buffa::types::put_len_delimited_header(5u32, __cache.consume_next(), buf);
            self.end_time.write_to(__cache, buf);
        }
        if self.include_incomplete {
            ::buffa::types::put_bool_field(6u32, self.include_incomplete, buf);
        }
        if self.include_reference {
            ::buffa::types::put_bool_field(7u32, self.include_reference, buf);
        }
        if !self.page_token.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.page_token, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.timeframe = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.limit = ::buffa::types::decode_uint32(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.start_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.end_time.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.include_incomplete = ::buffa::types::decode_bool(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.include_reference = ::buffa::types::decode_bool(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.page_token, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.symbol_id = 0u32;
        self.timeframe = ::buffa::EnumValue::from(0);
        self.limit = 0u32;
        self.start_time = ::buffa::MessageField::none();
        self.end_time = ::buffa::MessageField::none();
        self.include_incomplete = false;
        self.include_reference = false;
        self.page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetCandlesColumnsRequest {
    const PROTO_FQN: &'static str = "marketdata.v1.GetCandlesColumnsRequest";
    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 GetCandlesColumnsRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_CANDLES_COLUMNS_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetCandlesColumnsRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetCandlesColumnsRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetCandlesColumnsRequest>,
    is_wkt: false,
};
/// CandlePoint is one OHLCV bucket represented with scaled integers.
///
/// REST responses render these values as decimal strings in tuple order:
/// \[ts_sec, open, high, low, close, volume\].
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct CandlePoint {
    /// Candle bucket start timestamp, in seconds since epoch (UTC).
    ///
    /// Field 1: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    /// Opening price in quote units scaled by 1e6.
    ///
    /// Field 2: `open`
    #[serde(
        rename = "open",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub open: i64,
    /// Highest traded price in quote units scaled by 1e6.
    ///
    /// Field 3: `high`
    #[serde(
        rename = "high",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub high: i64,
    /// Lowest traded price in quote units scaled by 1e6.
    ///
    /// Field 4: `low`
    #[serde(
        rename = "low",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub low: i64,
    /// Closing price in quote units scaled by 1e6.
    ///
    /// Field 5: `close`
    #[serde(
        rename = "close",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub close: i64,
    /// Traded base-asset quantity scaled by the market's base asset quantity_scale
    /// from GetSpotConfig.
    ///
    /// Field 6: `volume`
    #[serde(
        rename = "volume",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub volume: i64,
    /// True only for WebSocket terminal updates of a closed bucket.
    /// Historical API rows and current open-candle rows set this to false.
    ///
    /// Field 7: `is_closed`
    #[serde(
        rename = "isClosed",
        alias = "is_closed",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub is_closed: bool,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CandlePoint {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CandlePoint")
            .field("ts_sec", &self.ts_sec)
            .field("open", &self.open)
            .field("high", &self.high)
            .field("low", &self.low)
            .field("close", &self.close)
            .field("volume", &self.volume)
            .field("is_closed", &self.is_closed)
            .finish()
    }
}
impl CandlePoint {
    /// 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/marketdata.v1.CandlePoint";
}
::buffa::impl_default_instance!(CandlePoint);
impl ::buffa::MessageName for CandlePoint {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "CandlePoint";
    const FULL_NAME: &'static str = "marketdata.v1.CandlePoint";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.CandlePoint";
}
impl ::buffa::Message for CandlePoint {
    /// 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.ts_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
        }
        if self.open != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.open) as u32;
        }
        if self.high != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.high) as u32;
        }
        if self.low != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.low) as u32;
        }
        if self.close != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.close) as u32;
        }
        if self.volume != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.volume) as u32;
        }
        if self.is_closed {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
        }
        if self.open != 0i64 {
            ::buffa::types::put_int64_field(2u32, self.open, buf);
        }
        if self.high != 0i64 {
            ::buffa::types::put_int64_field(3u32, self.high, buf);
        }
        if self.low != 0i64 {
            ::buffa::types::put_int64_field(4u32, self.low, buf);
        }
        if self.close != 0i64 {
            ::buffa::types::put_int64_field(5u32, self.close, buf);
        }
        if self.volume != 0i64 {
            ::buffa::types::put_int64_field(6u32, self.volume, buf);
        }
        if self.is_closed {
            ::buffa::types::put_bool_field(7u32, self.is_closed, 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.ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.open = ::buffa::types::decode_int64(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.high = ::buffa::types::decode_int64(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.low = ::buffa::types::decode_int64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.close = ::buffa::types::decode_int64(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.volume = ::buffa::types::decode_int64(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_closed = ::buffa::types::decode_bool(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.ts_sec = 0u64;
        self.open = 0i64;
        self.high = 0i64;
        self.low = 0i64;
        self.close = 0i64;
        self.volume = 0i64;
        self.is_closed = false;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for CandlePoint {
    const PROTO_FQN: &'static str = "marketdata.v1.CandlePoint";
    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 CandlePoint {
    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 __CANDLE_POINT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.CandlePoint",
    to_json: ::buffa::type_registry::any_to_json::<CandlePoint>,
    from_json: ::buffa::type_registry::any_from_json::<CandlePoint>,
    is_wkt: false,
};
/// GetCandlesResponse contains OHLCV candles for one spot market and timeframe.
///
/// Candles and reference_candles are ordered newest-first by ts_sec. REST
/// responses render price and volume values as decimal strings.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetCandlesResponse {
    /// Numeric spot market identifier echoed from the request.
    ///
    /// 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,
    /// Candle bucket size used for the returned series.
    ///
    /// Field 2: `timeframe`
    #[serde(
        rename = "timeframe",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub timeframe: ::buffa::EnumValue<Timeframe>,
    /// Primary market candle series, ordered newest-first by ts_sec.
    ///
    /// Field 3: `candles`
    #[serde(
        rename = "candles",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub candles: ::buffa::alloc::vec::Vec<CandlePoint>,
    /// Composite reference market candle series, ordered newest-first by ts_sec.
    /// Populated only when include_reference is true and reference data is
    /// available.
    ///
    /// Field 4: `reference_candles`
    #[serde(
        rename = "referenceCandles",
        alias = "reference_candles",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub reference_candles: ::buffa::alloc::vec::Vec<CandlePoint>,
    /// Opaque cursor for the next page. Empty when no more results exist.
    ///
    /// Field 5: `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 GetCandlesResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetCandlesResponse")
            .field("symbol_id", &self.symbol_id)
            .field("timeframe", &self.timeframe)
            .field("candles", &self.candles)
            .field("reference_candles", &self.reference_candles)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl GetCandlesResponse {
    /// 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/marketdata.v1.GetCandlesResponse";
}
::buffa::impl_default_instance!(GetCandlesResponse);
impl ::buffa::MessageName for GetCandlesResponse {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetCandlesResponse";
    const FULL_NAME: &'static str = "marketdata.v1.GetCandlesResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesResponse";
}
impl ::buffa::Message for GetCandlesResponse {
    /// 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;
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        for v in &self.candles {
            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;
        }
        for v in &self.reference_candles {
            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 _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        for v in &self.candles {
            ::buffa::types::put_len_delimited_header(3u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        for v in &self.reference_candles {
            ::buffa::types::put_len_delimited_header(4u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if !self.next_page_token.is_empty() {
            ::buffa::types::put_string_field(5u32, &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::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.timeframe = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::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.candles.push(elem);
            }
            4u32 => {
                ::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.reference_candles.push(elem);
            }
            5u32 => {
                ::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.symbol_id = 0u32;
        self.timeframe = ::buffa::EnumValue::from(0);
        self.candles.clear();
        self.reference_candles.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetCandlesResponse {
    const PROTO_FQN: &'static str = "marketdata.v1.GetCandlesResponse";
    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 GetCandlesResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_CANDLES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetCandlesResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetCandlesResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetCandlesResponse>,
    is_wkt: false,
};
/// GetCandlesColumnsResponse returns the same candle series as GetCandles but in columnar form.
/// This is optimized for charting clients that ingest arrays of each field (binary only).
///
/// Ordering: values are returned oldest-first (ascending ts_sec).
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetCandlesColumnsResponse {
    /// 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,
    /// Timeframe of this series.
    ///
    /// Field 2: `timeframe`
    #[serde(
        rename = "timeframe",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub timeframe: ::buffa::EnumValue<Timeframe>,
    /// Candle bucket start timestamps (seconds since epoch, UTC).
    ///
    /// Field 3: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub ts_sec: ::buffa::alloc::vec::Vec<u64>,
    /// Opening prices in quote units scaled by 1e6.
    ///
    /// Field 4: `open`
    #[serde(
        rename = "open",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub open: ::buffa::alloc::vec::Vec<i64>,
    /// Highest traded prices in quote units scaled by 1e6.
    ///
    /// Field 5: `high`
    #[serde(
        rename = "high",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub high: ::buffa::alloc::vec::Vec<i64>,
    /// Lowest traded prices in quote units scaled by 1e6.
    ///
    /// Field 6: `low`
    #[serde(
        rename = "low",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub low: ::buffa::alloc::vec::Vec<i64>,
    /// Closing prices in quote units scaled by 1e6.
    ///
    /// Field 7: `close`
    #[serde(
        rename = "close",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub close: ::buffa::alloc::vec::Vec<i64>,
    /// Traded base-asset quantities scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 8: `volume`
    #[serde(
        rename = "volume",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub volume: ::buffa::alloc::vec::Vec<i64>,
    /// Reference candle series in columnar form (same ordering as ts_sec: oldest-first).
    /// Only populated when request.include_reference=true.
    ///
    /// Field 9: `reference_ts_sec`
    #[serde(
        rename = "referenceTsSec",
        alias = "reference_ts_sec",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_ts_sec: ::buffa::alloc::vec::Vec<u64>,
    /// Reference opening prices in quote units scaled by 1e6.
    ///
    /// Field 10: `reference_open`
    #[serde(
        rename = "referenceOpen",
        alias = "reference_open",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_open: ::buffa::alloc::vec::Vec<i64>,
    /// Reference high prices in quote units scaled by 1e6.
    ///
    /// Field 11: `reference_high`
    #[serde(
        rename = "referenceHigh",
        alias = "reference_high",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_high: ::buffa::alloc::vec::Vec<i64>,
    /// Reference low prices in quote units scaled by 1e6.
    ///
    /// Field 12: `reference_low`
    #[serde(
        rename = "referenceLow",
        alias = "reference_low",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_low: ::buffa::alloc::vec::Vec<i64>,
    /// Reference closing prices in quote units scaled by 1e6.
    ///
    /// Field 13: `reference_close`
    #[serde(
        rename = "referenceClose",
        alias = "reference_close",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_close: ::buffa::alloc::vec::Vec<i64>,
    /// Reference traded base-asset quantities scaled by the pair's
    /// base_quantity_scale from GetSpotConfig.
    ///
    /// Field 14: `reference_volume`
    #[serde(
        rename = "referenceVolume",
        alias = "reference_volume",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub reference_volume: ::buffa::alloc::vec::Vec<i64>,
    /// Opaque cursor for the next page. Empty when no more results exist.
    ///
    /// Field 15: `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 GetCandlesColumnsResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetCandlesColumnsResponse")
            .field("symbol_id", &self.symbol_id)
            .field("timeframe", &self.timeframe)
            .field("ts_sec", &self.ts_sec)
            .field("open", &self.open)
            .field("high", &self.high)
            .field("low", &self.low)
            .field("close", &self.close)
            .field("volume", &self.volume)
            .field("reference_ts_sec", &self.reference_ts_sec)
            .field("reference_open", &self.reference_open)
            .field("reference_high", &self.reference_high)
            .field("reference_low", &self.reference_low)
            .field("reference_close", &self.reference_close)
            .field("reference_volume", &self.reference_volume)
            .field("next_page_token", &self.next_page_token)
            .finish()
    }
}
impl GetCandlesColumnsResponse {
    /// 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/marketdata.v1.GetCandlesColumnsResponse";
}
::buffa::impl_default_instance!(GetCandlesColumnsResponse);
impl ::buffa::MessageName for GetCandlesColumnsResponse {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetCandlesColumnsResponse";
    const FULL_NAME: &'static str = "marketdata.v1.GetCandlesColumnsResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesColumnsResponse";
}
impl ::buffa::Message for GetCandlesColumnsResponse {
    /// 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;
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.ts_sec.is_empty() {
            let payload: u32 = self
                .ts_sec
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        if !self.open.is_empty() {
            let payload: u32 = self
                .open
                .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;
        }
        if !self.high.is_empty() {
            let payload: u32 = self
                .high
                .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;
        }
        if !self.low.is_empty() {
            let payload: u32 = self
                .low
                .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;
        }
        if !self.close.is_empty() {
            let payload: u32 = self
                .close
                .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;
        }
        if !self.volume.is_empty() {
            let payload: u32 = self
                .volume
                .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;
        }
        if !self.reference_ts_sec.is_empty() {
            let payload: u32 = self
                .reference_ts_sec
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        if !self.reference_open.is_empty() {
            let payload: u32 = self
                .reference_open
                .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;
        }
        if !self.reference_high.is_empty() {
            let payload: u32 = self
                .reference_high
                .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;
        }
        if !self.reference_low.is_empty() {
            let payload: u32 = self
                .reference_low
                .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;
        }
        if !self.reference_close.is_empty() {
            let payload: u32 = self
                .reference_close
                .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;
        }
        if !self.reference_volume.is_empty() {
            let payload: u32 = self
                .reference_volume
                .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;
        }
        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 _;
        if self.symbol_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if !self.ts_sec.is_empty() {
            let payload: u32 = self
                .ts_sec
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(3u32, payload, buf);
            for &v in &self.ts_sec {
                ::buffa::types::encode_uint64(v, buf);
            }
        }
        if !self.open.is_empty() {
            let payload: u32 = self
                .open
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(4u32, payload, buf);
            for &v in &self.open {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.high.is_empty() {
            let payload: u32 = self
                .high
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(5u32, payload, buf);
            for &v in &self.high {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.low.is_empty() {
            let payload: u32 = self
                .low
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(6u32, payload, buf);
            for &v in &self.low {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.close.is_empty() {
            let payload: u32 = self
                .close
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(7u32, payload, buf);
            for &v in &self.close {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.volume.is_empty() {
            let payload: u32 = self
                .volume
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(8u32, payload, buf);
            for &v in &self.volume {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.reference_ts_sec.is_empty() {
            let payload: u32 = self
                .reference_ts_sec
                .iter()
                .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(9u32, payload, buf);
            for &v in &self.reference_ts_sec {
                ::buffa::types::encode_uint64(v, buf);
            }
        }
        if !self.reference_open.is_empty() {
            let payload: u32 = self
                .reference_open
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(10u32, payload, buf);
            for &v in &self.reference_open {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.reference_high.is_empty() {
            let payload: u32 = self
                .reference_high
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(11u32, payload, buf);
            for &v in &self.reference_high {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.reference_low.is_empty() {
            let payload: u32 = self
                .reference_low
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(12u32, payload, buf);
            for &v in &self.reference_low {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.reference_close.is_empty() {
            let payload: u32 = self
                .reference_close
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(13u32, payload, buf);
            for &v in &self.reference_close {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.reference_volume.is_empty() {
            let payload: u32 = self
                .reference_volume
                .iter()
                .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::types::put_len_delimited_header(14u32, payload, buf);
            for &v in &self.reference_volume {
                ::buffa::types::encode_int64(v, buf);
            }
        }
        if !self.next_page_token.is_empty() {
            ::buffa::types::put_string_field(15u32, &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::Varint,
                )?;
                self.symbol_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.timeframe = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.ts_sec.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.ts_sec.push(::buffa::types::decode_uint64(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.ts_sec.push(::buffa::types::decode_uint64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            4u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.open.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.open.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.open.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            5u32 => {
                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.high.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.high.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.high.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            6u32 => {
                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.low.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.low.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.low.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            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.close.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.close.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.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            8u32 => {
                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.volume.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.volume.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.volume.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            9u32 => {
                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.reference_ts_sec.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_ts_sec
                            .push(::buffa::types::decode_uint64(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.reference_ts_sec.push(::buffa::types::decode_uint64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            10u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.reference_open.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_open
                            .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.reference_open.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            11u32 => {
                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.reference_high.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_high
                            .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.reference_high.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            12u32 => {
                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.reference_low.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_low
                            .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.reference_low.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            13u32 => {
                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.reference_close.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_close
                            .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.reference_close.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            14u32 => {
                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.reference_volume.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.reference_volume
                            .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.reference_volume.push(::buffa::types::decode_int64(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            15u32 => {
                ::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.symbol_id = 0u32;
        self.timeframe = ::buffa::EnumValue::from(0);
        self.ts_sec.clear();
        self.open.clear();
        self.high.clear();
        self.low.clear();
        self.close.clear();
        self.volume.clear();
        self.reference_ts_sec.clear();
        self.reference_open.clear();
        self.reference_high.clear();
        self.reference_low.clear();
        self.reference_close.clear();
        self.reference_volume.clear();
        self.next_page_token.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetCandlesColumnsResponse {
    const PROTO_FQN: &'static str = "marketdata.v1.GetCandlesColumnsResponse";
    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 GetCandlesColumnsResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_CANDLES_COLUMNS_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetCandlesColumnsResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetCandlesColumnsResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetCandlesColumnsResponse>,
    is_wkt: false,
};
/// ---------------------------------------------------------------------------
/// Candle contains one public OHLCV bucket.
/// ---------------------------------------------------------------------------
///
/// Candle represents a single OHLCV bucket for a symbol and timeframe.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct Candle {
    /// 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,
    /// timeframe of this candle
    ///
    /// Field 2: `timeframe`
    #[serde(
        rename = "timeframe",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub timeframe: ::buffa::EnumValue<Timeframe>,
    /// bucket start timestamp (seconds since epoch, UTC)
    ///
    /// Field 3: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    /// opening price in quote units scaled by 1e6
    ///
    /// Field 4: `open`
    #[serde(
        rename = "open",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub open: i64,
    /// highest traded price in quote units scaled by 1e6
    ///
    /// Field 5: `high`
    #[serde(
        rename = "high",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub high: i64,
    /// lowest traded price in quote units scaled by 1e6
    ///
    /// Field 6: `low`
    #[serde(
        rename = "low",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub low: i64,
    /// closing price in quote units scaled by 1e6
    ///
    /// Field 7: `close`
    #[serde(
        rename = "close",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub close: i64,
    /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
    /// GetSpotConfig.
    ///
    /// Field 8: `volume`
    #[serde(
        rename = "volume",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub volume: i64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Candle {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Candle")
            .field("symbol_id", &self.symbol_id)
            .field("timeframe", &self.timeframe)
            .field("ts_sec", &self.ts_sec)
            .field("open", &self.open)
            .field("high", &self.high)
            .field("low", &self.low)
            .field("close", &self.close)
            .field("volume", &self.volume)
            .finish()
    }
}
impl Candle {
    /// 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/marketdata.v1.Candle";
}
::buffa::impl_default_instance!(Candle);
impl ::buffa::MessageName for Candle {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "Candle";
    const FULL_NAME: &'static str = "marketdata.v1.Candle";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.Candle";
}
impl ::buffa::Message for Candle {
    /// 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;
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.ts_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
        }
        if self.open != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.open) as u32;
        }
        if self.high != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.high) as u32;
        }
        if self.low != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.low) as u32;
        }
        if self.close != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.close) as u32;
        }
        if self.volume != 0i64 {
            size += 1u32 + ::buffa::types::int64_encoded_len(self.volume) 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);
        }
        {
            let val = self.timeframe.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(2u32, val, buf);
            }
        }
        if self.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(3u32, self.ts_sec, buf);
        }
        if self.open != 0i64 {
            ::buffa::types::put_int64_field(4u32, self.open, buf);
        }
        if self.high != 0i64 {
            ::buffa::types::put_int64_field(5u32, self.high, buf);
        }
        if self.low != 0i64 {
            ::buffa::types::put_int64_field(6u32, self.low, buf);
        }
        if self.close != 0i64 {
            ::buffa::types::put_int64_field(7u32, self.close, buf);
        }
        if self.volume != 0i64 {
            ::buffa::types::put_int64_field(8u32, self.volume, 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::Varint,
                )?;
                self.timeframe = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_sec = ::buffa::types::decode_uint64(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.open = ::buffa::types::decode_int64(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.high = ::buffa::types::decode_int64(buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.low = ::buffa::types::decode_int64(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.close = ::buffa::types::decode_int64(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.volume = ::buffa::types::decode_int64(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.timeframe = ::buffa::EnumValue::from(0);
        self.ts_sec = 0u64;
        self.open = 0i64;
        self.high = 0i64;
        self.low = 0i64;
        self.close = 0i64;
        self.volume = 0i64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Candle {
    const PROTO_FQN: &'static str = "marketdata.v1.Candle";
    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 Candle {
    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 __CANDLE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.Candle",
    to_json: ::buffa::type_registry::any_to_json::<Candle>,
    from_json: ::buffa::type_registry::any_from_json::<Candle>,
    is_wkt: false,
};
/// ---------------------------------------------------------------------------
/// GetSpotConfig: spot assets and pair reference data.
/// ---------------------------------------------------------------------------
///
/// AssetConfig describes one spot asset returned by GetSpotConfig.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct AssetConfig {
    /// Asset code, e.g. "USDT" or "BTC".
    ///
    /// Field 1: `asset`
    #[serde(
        rename = "asset",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub asset: ::buffa::alloc::string::String,
    /// Stable numeric asset id used by account, balance, and order APIs.
    ///
    /// Field 2: `ledger_id`
    #[serde(
        rename = "ledgerId",
        alias = "ledger_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub ledger_id: u32,
    /// Human-friendly display name, e.g. "Bitcoin".
    ///
    /// Field 3: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    /// Suggested decimal precision for displaying user-facing asset amounts.
    ///
    /// Field 4: `quantity_display_decimals`
    #[serde(
        rename = "quantityDisplayDecimals",
        alias = "quantity_display_decimals",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub quantity_display_decimals: u32,
    /// Integer scale for quantities and balances in this asset (0..18).
    /// A scale of 8 means one whole asset is represented as 100000000 in scaled
    /// integer fields such as qty_scaled.
    ///
    /// Field 5: `quantity_scale`
    #[serde(
        rename = "quantityScale",
        alias = "quantity_scale",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub quantity_scale: u32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for AssetConfig {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("AssetConfig")
            .field("asset", &self.asset)
            .field("ledger_id", &self.ledger_id)
            .field("name", &self.name)
            .field("quantity_display_decimals", &self.quantity_display_decimals)
            .field("quantity_scale", &self.quantity_scale)
            .finish()
    }
}
impl AssetConfig {
    /// 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/marketdata.v1.AssetConfig";
}
::buffa::impl_default_instance!(AssetConfig);
impl ::buffa::MessageName for AssetConfig {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "AssetConfig";
    const FULL_NAME: &'static str = "marketdata.v1.AssetConfig";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.AssetConfig";
}
impl ::buffa::Message for AssetConfig {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.asset.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.asset) as u32;
        }
        if self.ledger_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.ledger_id) as u32;
        }
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
        }
        if self.quantity_display_decimals != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.quantity_display_decimals)
                        as u32;
        }
        if self.quantity_scale != 0u32 {
            size
                += 1u32 + ::buffa::types::uint32_encoded_len(self.quantity_scale) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.asset.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.asset, buf);
        }
        if self.ledger_id != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.ledger_id, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.name, buf);
        }
        if self.quantity_display_decimals != 0u32 {
            ::buffa::types::put_uint32_field(4u32, self.quantity_display_decimals, buf);
        }
        if self.quantity_scale != 0u32 {
            ::buffa::types::put_uint32_field(5u32, self.quantity_scale, 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,
                )?;
                ::buffa::types::merge_string(&mut self.asset, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ledger_id = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quantity_display_decimals = ::buffa::types::decode_uint32(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quantity_scale = ::buffa::types::decode_uint32(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.asset.clear();
        self.ledger_id = 0u32;
        self.name.clear();
        self.quantity_display_decimals = 0u32;
        self.quantity_scale = 0u32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for AssetConfig {
    const PROTO_FQN: &'static str = "marketdata.v1.AssetConfig";
    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 AssetConfig {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __ASSET_CONFIG_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.AssetConfig",
    to_json: ::buffa::type_registry::any_to_json::<AssetConfig>,
    from_json: ::buffa::type_registry::any_from_json::<AssetConfig>,
    is_wkt: false,
};
/// PairMarketdataConfig describes market-data display settings for a spot pair.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct PairMarketdataConfig {
    /// Suggested order book aggregation bucket sizes in quote-asset price units,
    /// e.g. 0.01, 0.1, 1, or 10.
    ///
    /// Field 1: `orderbook_price_buckets`
    #[serde(
        rename = "orderbookPriceBuckets",
        alias = "orderbook_price_buckets",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub orderbook_price_buckets: ::buffa::alloc::vec::Vec<f64>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for PairMarketdataConfig {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("PairMarketdataConfig")
            .field("orderbook_price_buckets", &self.orderbook_price_buckets)
            .finish()
    }
}
impl PairMarketdataConfig {
    /// 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/marketdata.v1.PairMarketdataConfig";
}
::buffa::impl_default_instance!(PairMarketdataConfig);
impl ::buffa::MessageName for PairMarketdataConfig {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "PairMarketdataConfig";
    const FULL_NAME: &'static str = "marketdata.v1.PairMarketdataConfig";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.PairMarketdataConfig";
}
impl ::buffa::Message for PairMarketdataConfig {
    /// 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.orderbook_price_buckets.is_empty() {
            let payload: u32 = self.orderbook_price_buckets.len() as u32
                * ::buffa::types::FIXED64_ENCODED_LEN as u32;
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.orderbook_price_buckets.is_empty() {
            let payload: u32 = self.orderbook_price_buckets.len() as u32
                * ::buffa::types::FIXED64_ENCODED_LEN as u32;
            ::buffa::types::put_len_delimited_header(1u32, payload, buf);
            for &v in &self.orderbook_price_buckets {
                ::buffa::types::encode_double(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 => {
                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.orderbook_price_buckets.reserve(len / 8usize);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.orderbook_price_buckets
                            .push(::buffa::types::decode_double(&mut limited)?);
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Fixed64 {
                    self.orderbook_price_buckets
                        .push(::buffa::types::decode_double(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.orderbook_price_buckets.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for PairMarketdataConfig {
    const PROTO_FQN: &'static str = "marketdata.v1.PairMarketdataConfig";
    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 PairMarketdataConfig {
    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 __PAIR_MARKETDATA_CONFIG_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.PairMarketdataConfig",
    to_json: ::buffa::type_registry::any_to_json::<PairMarketdataConfig>,
    from_json: ::buffa::type_registry::any_from_json::<PairMarketdataConfig>,
    is_wkt: false,
};
/// PairConfig describes one spot trading pair and its trading constraints.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct PairConfig {
    /// Stable numeric pair id used by low-latency ConnectRPC requests and streams.
    ///
    /// 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,
    /// Trading 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,
    /// Base asset code. For BTC-USDT, this is "BTC".
    ///
    /// Field 3: `base_asset`
    #[serde(
        rename = "baseAsset",
        alias = "base_asset",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub base_asset: ::buffa::alloc::string::String,
    /// Quote asset code. For BTC-USDT, this is "USDT".
    ///
    /// Field 4: `quote_asset`
    #[serde(
        rename = "quoteAsset",
        alias = "quote_asset",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub quote_asset: ::buffa::alloc::string::String,
    /// Minimum allowed price increment as a decimal string in quote-asset units.
    /// Prices use 6 decimal places in scaled integer fields; for example "0.01"
    /// means orders must be priced in 0.01 quote-asset increments.
    ///
    /// Field 5: `tick_size`
    #[serde(
        rename = "tickSize",
        alias = "tick_size",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub tick_size: ::buffa::alloc::string::String,
    /// Minimum allowed quantity increment as a decimal string in base-asset units.
    ///
    /// Field 6: `step_size`
    #[serde(
        rename = "stepSize",
        alias = "step_size",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub step_size: ::buffa::alloc::string::String,
    /// Minimum order notional as a decimal string in quote-asset units.
    ///
    /// Field 7: `min_notional_quote`
    #[serde(
        rename = "minNotionalQuote",
        alias = "min_notional_quote",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub min_notional_quote: ::buffa::alloc::string::String,
    /// Minimum order quantity as a decimal string in base-asset units.
    ///
    /// Field 8: `min_qty_base`
    #[serde(
        rename = "minQtyBase",
        alias = "min_qty_base",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub min_qty_base: ::buffa::alloc::string::String,
    /// Whether BUY order fees may be paid from the base asset instead of the
    /// spent quote asset when the order request selects the base fee asset.
    ///
    /// Field 9: `allow_buy_fee_from_base`
    #[serde(
        rename = "allowBuyFeeFromBase",
        alias = "allow_buy_fee_from_base",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub allow_buy_fee_from_base: bool,
    /// Quantity scale for base-asset amounts in this pair.
    ///
    /// Field 10: `base_quantity_scale`
    #[serde(
        rename = "baseQuantityScale",
        alias = "base_quantity_scale",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub base_quantity_scale: u32,
    /// Quantity scale for quote-asset amounts in this pair.
    ///
    /// Field 11: `quote_quantity_scale`
    #[serde(
        rename = "quoteQuantityScale",
        alias = "quote_quantity_scale",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub quote_quantity_scale: u32,
    /// Market-data display settings for this pair.
    ///
    /// Field 12: `marketdata`
    #[serde(
        rename = "marketdata",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub marketdata: ::buffa::MessageField<PairMarketdataConfig>,
    /// Scheduled listing timestamp. When unset, the pair has no explicit future
    /// listing time.
    ///
    /// Field 13: `listing_at`
    #[serde(
        rename = "listingAt",
        alias = "listing_at",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub listing_at: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Scheduled delisting timestamp. When unset, the pair has no explicit
    /// delisting time.
    ///
    /// Field 14: `delisting_at`
    #[serde(
        rename = "delistingAt",
        alias = "delisting_at",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub delisting_at: ::buffa::MessageField<::buffa_types::google::protobuf::Timestamp>,
    /// Current trading status.
    ///
    /// Field 15: `status`
    #[serde(
        rename = "status",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub status: ::buffa::EnumValue<PairStatus>,
    /// Default MARKET order slippage cap for BUY orders, in basis points
    /// (1 bp = 0.01%). A request-level slippage setting can override this value.
    ///
    /// Field 16: `default_market_slippage_bps_buy`
    #[serde(
        rename = "defaultMarketSlippageBpsBuy",
        alias = "default_market_slippage_bps_buy",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub default_market_slippage_bps_buy: i32,
    /// Default MARKET order slippage cap for SELL orders, in basis points
    /// (1 bp = 0.01%). A request-level slippage setting can override this value.
    ///
    /// Field 17: `default_market_slippage_bps_sell`
    #[serde(
        rename = "defaultMarketSlippageBpsSell",
        alias = "default_market_slippage_bps_sell",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub default_market_slippage_bps_sell: i32,
    /// Maximum allowed drift between client reference price and server reference
    /// price for MARKET orders, in basis points (1 bp = 0.01%), when client
    /// reference pricing is used.
    ///
    /// Field 18: `max_client_ref_drift_bps`
    #[serde(
        rename = "maxClientRefDriftBps",
        alias = "max_client_ref_drift_bps",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub max_client_ref_drift_bps: i32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for PairConfig {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("PairConfig")
            .field("symbol_id", &self.symbol_id)
            .field("symbol", &self.symbol)
            .field("base_asset", &self.base_asset)
            .field("quote_asset", &self.quote_asset)
            .field("tick_size", &self.tick_size)
            .field("step_size", &self.step_size)
            .field("min_notional_quote", &self.min_notional_quote)
            .field("min_qty_base", &self.min_qty_base)
            .field("allow_buy_fee_from_base", &self.allow_buy_fee_from_base)
            .field("base_quantity_scale", &self.base_quantity_scale)
            .field("quote_quantity_scale", &self.quote_quantity_scale)
            .field("marketdata", &self.marketdata)
            .field("listing_at", &self.listing_at)
            .field("delisting_at", &self.delisting_at)
            .field("status", &self.status)
            .field(
                "default_market_slippage_bps_buy",
                &self.default_market_slippage_bps_buy,
            )
            .field(
                "default_market_slippage_bps_sell",
                &self.default_market_slippage_bps_sell,
            )
            .field("max_client_ref_drift_bps", &self.max_client_ref_drift_bps)
            .finish()
    }
}
impl PairConfig {
    /// 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/marketdata.v1.PairConfig";
}
::buffa::impl_default_instance!(PairConfig);
impl ::buffa::MessageName for PairConfig {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "PairConfig";
    const FULL_NAME: &'static str = "marketdata.v1.PairConfig";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.PairConfig";
}
impl ::buffa::Message for PairConfig {
    /// 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.base_asset.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.base_asset) as u32;
        }
        if !self.quote_asset.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.quote_asset) as u32;
        }
        if !self.tick_size.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.tick_size) as u32;
        }
        if !self.step_size.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.step_size) as u32;
        }
        if !self.min_notional_quote.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.min_notional_quote)
                        as u32;
        }
        if !self.min_qty_base.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.min_qty_base) as u32;
        }
        if self.allow_buy_fee_from_base {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if self.base_quantity_scale != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.base_quantity_scale)
                        as u32;
        }
        if self.quote_quantity_scale != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.quote_quantity_scale)
                        as u32;
        }
        if self.marketdata.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.marketdata.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.listing_at.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.listing_at.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if self.delisting_at.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.delisting_at.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        {
            let val = self.status.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.default_market_slippage_bps_buy != 0i32 {
            size
                += 2u32
                    + ::buffa::types::int32_encoded_len(
                        self.default_market_slippage_bps_buy,
                    ) as u32;
        }
        if self.default_market_slippage_bps_sell != 0i32 {
            size
                += 2u32
                    + ::buffa::types::int32_encoded_len(
                        self.default_market_slippage_bps_sell,
                    ) as u32;
        }
        if self.max_client_ref_drift_bps != 0i32 {
            size
                += 2u32
                    + ::buffa::types::int32_encoded_len(self.max_client_ref_drift_bps)
                        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.base_asset.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.base_asset, buf);
        }
        if !self.quote_asset.is_empty() {
            ::buffa::types::put_string_field(4u32, &self.quote_asset, buf);
        }
        if !self.tick_size.is_empty() {
            ::buffa::types::put_string_field(5u32, &self.tick_size, buf);
        }
        if !self.step_size.is_empty() {
            ::buffa::types::put_string_field(6u32, &self.step_size, buf);
        }
        if !self.min_notional_quote.is_empty() {
            ::buffa::types::put_string_field(7u32, &self.min_notional_quote, buf);
        }
        if !self.min_qty_base.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.min_qty_base, buf);
        }
        if self.allow_buy_fee_from_base {
            ::buffa::types::put_bool_field(9u32, self.allow_buy_fee_from_base, buf);
        }
        if self.base_quantity_scale != 0u32 {
            ::buffa::types::put_uint32_field(10u32, self.base_quantity_scale, buf);
        }
        if self.quote_quantity_scale != 0u32 {
            ::buffa::types::put_uint32_field(11u32, self.quote_quantity_scale, buf);
        }
        if self.marketdata.is_set() {
            ::buffa::types::put_len_delimited_header(12u32, __cache.consume_next(), buf);
            self.marketdata.write_to(__cache, buf);
        }
        if self.listing_at.is_set() {
            ::buffa::types::put_len_delimited_header(13u32, __cache.consume_next(), buf);
            self.listing_at.write_to(__cache, buf);
        }
        if self.delisting_at.is_set() {
            ::buffa::types::put_len_delimited_header(14u32, __cache.consume_next(), buf);
            self.delisting_at.write_to(__cache, buf);
        }
        {
            let val = self.status.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(15u32, val, buf);
            }
        }
        if self.default_market_slippage_bps_buy != 0i32 {
            ::buffa::types::put_int32_field(
                16u32,
                self.default_market_slippage_bps_buy,
                buf,
            );
        }
        if self.default_market_slippage_bps_sell != 0i32 {
            ::buffa::types::put_int32_field(
                17u32,
                self.default_market_slippage_bps_sell,
                buf,
            );
        }
        if self.max_client_ref_drift_bps != 0i32 {
            ::buffa::types::put_int32_field(18u32, self.max_client_ref_drift_bps, 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::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.base_asset, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.quote_asset, buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.tick_size, buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.step_size, buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.min_notional_quote, buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.min_qty_base, buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.allow_buy_fee_from_base = ::buffa::types::decode_bool(buf)?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.base_quantity_scale = ::buffa::types::decode_uint32(buf)?;
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.quote_quantity_scale = ::buffa::types::decode_uint32(buf)?;
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.marketdata.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            13u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.listing_at.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            14u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.delisting_at.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.status = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            16u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.default_market_slippage_bps_buy = ::buffa::types::decode_int32(
                    buf,
                )?;
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.default_market_slippage_bps_sell = ::buffa::types::decode_int32(
                    buf,
                )?;
            }
            18u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.max_client_ref_drift_bps = ::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.symbol_id = 0u32;
        self.symbol.clear();
        self.base_asset.clear();
        self.quote_asset.clear();
        self.tick_size.clear();
        self.step_size.clear();
        self.min_notional_quote.clear();
        self.min_qty_base.clear();
        self.allow_buy_fee_from_base = false;
        self.base_quantity_scale = 0u32;
        self.quote_quantity_scale = 0u32;
        self.marketdata = ::buffa::MessageField::none();
        self.listing_at = ::buffa::MessageField::none();
        self.delisting_at = ::buffa::MessageField::none();
        self.status = ::buffa::EnumValue::from(0);
        self.default_market_slippage_bps_buy = 0i32;
        self.default_market_slippage_bps_sell = 0i32;
        self.max_client_ref_drift_bps = 0i32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for PairConfig {
    const PROTO_FQN: &'static str = "marketdata.v1.PairConfig";
    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 PairConfig {
    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 __PAIR_CONFIG_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.PairConfig",
    to_json: ::buffa::type_registry::any_to_json::<PairConfig>,
    from_json: ::buffa::type_registry::any_from_json::<PairConfig>,
    is_wkt: false,
};
/// GetSpotConfigRequest has no parameters.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetSpotConfigRequest {
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetSpotConfigRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetSpotConfigRequest").finish()
    }
}
impl GetSpotConfigRequest {
    /// 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/marketdata.v1.GetSpotConfigRequest";
}
::buffa::impl_default_instance!(GetSpotConfigRequest);
impl ::buffa::MessageName for GetSpotConfigRequest {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetSpotConfigRequest";
    const FULL_NAME: &'static str = "marketdata.v1.GetSpotConfigRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetSpotConfigRequest";
}
impl ::buffa::Message for GetSpotConfigRequest {
    /// 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;
        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 _;
        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() {
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetSpotConfigRequest {
    const PROTO_FQN: &'static str = "marketdata.v1.GetSpotConfigRequest";
    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 GetSpotConfigRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_SPOT_CONFIG_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetSpotConfigRequest",
    to_json: ::buffa::type_registry::any_to_json::<GetSpotConfigRequest>,
    from_json: ::buffa::type_registry::any_from_json::<GetSpotConfigRequest>,
    is_wkt: false,
};
/// GetSpotConfigResponse contains a cacheable spot reference-data snapshot.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct GetSpotConfigResponse {
    /// Assets ordered by asset code in ascending alphabetical order.
    ///
    /// Field 1: `assets`
    #[serde(
        rename = "assets",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub assets: ::buffa::alloc::vec::Vec<AssetConfig>,
    /// Pairs ordered by symbol in ascending alphabetical order.
    ///
    /// Field 2: `pairs`
    #[serde(
        rename = "pairs",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub pairs: ::buffa::alloc::vec::Vec<PairConfig>,
    /// Snapshot generation timestamp, in seconds since the Unix epoch (UTC).
    ///
    /// Field 3: `ts_sec`
    #[serde(
        rename = "tsSec",
        alias = "ts_sec",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub ts_sec: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GetSpotConfigResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GetSpotConfigResponse")
            .field("assets", &self.assets)
            .field("pairs", &self.pairs)
            .field("ts_sec", &self.ts_sec)
            .finish()
    }
}
impl GetSpotConfigResponse {
    /// 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/marketdata.v1.GetSpotConfigResponse";
}
::buffa::impl_default_instance!(GetSpotConfigResponse);
impl ::buffa::MessageName for GetSpotConfigResponse {
    const PACKAGE: &'static str = "marketdata.v1";
    const NAME: &'static str = "GetSpotConfigResponse";
    const FULL_NAME: &'static str = "marketdata.v1.GetSpotConfigResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetSpotConfigResponse";
}
impl ::buffa::Message for GetSpotConfigResponse {
    /// 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.assets {
            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;
        }
        for v in &self.pairs {
            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_sec != 0u64 {
            size += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) 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.assets {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        for v in &self.pairs {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        if self.ts_sec != 0u64 {
            ::buffa::types::put_uint64_field(3u32, self.ts_sec, 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.assets.push(elem);
            }
            2u32 => {
                ::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.pairs.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.ts_sec = ::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.assets.clear();
        self.pairs.clear();
        self.ts_sec = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GetSpotConfigResponse {
    const PROTO_FQN: &'static str = "marketdata.v1.GetSpotConfigResponse";
    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 GetSpotConfigResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __GET_SPOT_CONFIG_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/marketdata.v1.GetSpotConfigResponse",
    to_json: ::buffa::type_registry::any_to_json::<GetSpotConfigResponse>,
    from_json: ::buffa::type_registry::any_from_json::<GetSpotConfigResponse>,
    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::*;
        /// HeatmapTimeRange selects historical buckets by \[start_time, end_time\] (UTC).
        /// At least one bound is required.
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapTimeRangeView<'a> {
            /// Inclusive lower bound in UTC. Omit to leave the lower bound open.
            ///
            /// Field 1: `start_time`
            pub start_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Inclusive upper bound in UTC. Omit to leave the upper bound open.
            ///
            /// Field 2: `end_time`
            pub end_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapTimeRangeView<'a> {
            type Owned = super::super::HeatmapTimeRange;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.start_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.start_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.end_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.end_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView 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::HeatmapTimeRange,
                ::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::HeatmapTimeRange,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapTimeRange {
                    start_time: match self.start_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    end_time: match self.end_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapTimeRangeView<'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.start_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.start_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.end_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.end_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.start_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.start_time.write_to(__cache, buf);
                }
                if self.end_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.end_time.write_to(__cache, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for HeatmapTimeRangeView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                {
                    if let ::core::option::Option::Some(__v) = self
                        .start_time
                        .as_option()
                    {
                        __map.serialize_entry("startTime", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.end_time.as_option()
                    {
                        __map.serialize_entry("endTime", __v)?;
                    }
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapTimeRangeView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapTimeRange";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapTimeRange";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapTimeRange";
        }
        ::buffa::impl_default_view_instance!(HeatmapTimeRangeView);
        ::buffa::impl_view_reborrow!(HeatmapTimeRangeView);
        /** Self-contained, `'static` owned view of a `HeatmapTimeRange` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapTimeRangeView`]`<'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 [`HeatmapTimeRangeView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapTimeRangeOwnedView(
            ::buffa::OwnedView<HeatmapTimeRangeView<'static>>,
        );
        impl HeatmapTimeRangeOwnedView {
            /// 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(
                    HeatmapTimeRangeOwnedView(::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(
                    HeatmapTimeRangeOwnedView(
                        ::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::HeatmapTimeRange,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapTimeRangeOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapTimeRangeView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapTimeRangeView<'_> {
                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::HeatmapTimeRange,
                ::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()
            }
            /// Inclusive lower bound in UTC. Omit to leave the lower bound open.
            ///
            /// Field 1: `start_time`
            #[must_use]
            pub fn start_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().start_time
            }
            /// Inclusive upper bound in UTC. Omit to leave the upper bound open.
            ///
            /// Field 2: `end_time`
            #[must_use]
            pub fn end_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().end_time
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapTimeRangeView<'static>>>
        for HeatmapTimeRangeOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapTimeRangeView<'static>>) -> Self {
                HeatmapTimeRangeOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapTimeRangeOwnedView>
        for ::buffa::OwnedView<HeatmapTimeRangeView<'static>> {
            fn from(wrapper: HeatmapTimeRangeOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapTimeRangeView<'static>>>
        for HeatmapTimeRangeOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapTimeRangeView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapTimeRange {
            type View<'a> = HeatmapTimeRangeView<'a>;
            type ViewHandle = HeatmapTimeRangeOwnedView;
        }
        impl ::serde::Serialize for HeatmapTimeRangeOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetOrderbookHeatmapRequest fetches historical heatmap buckets.
        #[derive(Clone, Debug, Default)]
        pub struct GetOrderbookHeatmapRequestView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Heatmap bucket interval.
            ///
            /// Field 2: `interval`
            pub interval: ::buffa::EnumValue<super::super::HeatmapInterval>,
            /// Top-N levels per side included in each bucket.
            ///
            /// Field 3: `depth`
            pub depth: ::buffa::EnumValue<super::super::HeatmapDepth>,
            /// Absolute time range for the first page. Reuse the same request filters and
            /// pass page_token from the prior response to continue older buckets.
            ///
            /// Field 4: `time_range`
            pub time_range: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapTimeRangeView<'a>,
            >,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, interval, depth, quantity mode, and the original time
            /// range.
            ///
            /// Field 5: `page_token`
            pub page_token: &'a str,
            /// Maximum number of delta buckets returned (min 1, max 20000).
            /// This limit counts only `chain.deltas`; `chain.base_keyframe` is not counted.
            ///
            /// Field 6: `limit`
            pub limit: u32,
            /// Quantity mode used for qty_scaled in snapshot/delta levels:
            /// - CLOSE: end-of-bucket quantity
            /// - PEAK: intra-bucket peak quantity
            ///
            /// Field 7: `quantity_mode`
            pub quantity_mode: ::buffa::EnumValue<super::super::HeatmapQuantityMode>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetOrderbookHeatmapRequestView<'a> {
            type Owned = super::super::GetOrderbookHeatmapRequest;
            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::Varint,
                        )?;
                        view.interval = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.depth = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.time_range.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.time_range = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapTimeRangeView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quantity_mode = ::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::GetOrderbookHeatmapRequest,
                ::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::GetOrderbookHeatmapRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetOrderbookHeatmapRequest {
                    symbol_id: self.symbol_id,
                    interval: self.interval,
                    depth: self.depth,
                    time_range: match self.time_range.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapTimeRange,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    page_token: self.page_token.to_string(),
                    limit: self.limit,
                    quantity_mode: self.quantity_mode,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetOrderbookHeatmapRequestView<'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;
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.depth.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.time_range.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.time_range.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                as u32;
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                {
                    let val = self.depth.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(3u32, val, buf);
                    }
                }
                if self.time_range.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.time_range.write_to(__cache, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(5u32, &self.page_token, buf);
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(6u32, self.limit, buf);
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(7u32, 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 GetOrderbookHeatmapRequestView<'__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_default_enum_value(
                    &self.interval,
                ) {
                    __map.serialize_entry("interval", &self.interval)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.depth) {
                    __map.serialize_entry("depth", &self.depth)?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .time_range
                        .as_option()
                    {
                        __map.serialize_entry("timeRange", __v)?;
                    }
                }
                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_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.quantity_mode,
                ) {
                    __map.serialize_entry("quantityMode", &self.quantity_mode)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetOrderbookHeatmapRequestView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetOrderbookHeatmapRequest";
            const FULL_NAME: &'static str = "marketdata.v1.GetOrderbookHeatmapRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapRequest";
        }
        ::buffa::impl_default_view_instance!(GetOrderbookHeatmapRequestView);
        ::buffa::impl_view_reborrow!(GetOrderbookHeatmapRequestView);
        /** Self-contained, `'static` owned view of a `GetOrderbookHeatmapRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetOrderbookHeatmapRequestView`]`<'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 [`GetOrderbookHeatmapRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetOrderbookHeatmapRequestOwnedView(
            ::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>>,
        );
        impl GetOrderbookHeatmapRequestOwnedView {
            /// 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(
                    GetOrderbookHeatmapRequestOwnedView(
                        ::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(
                    GetOrderbookHeatmapRequestOwnedView(
                        ::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::GetOrderbookHeatmapRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetOrderbookHeatmapRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetOrderbookHeatmapRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetOrderbookHeatmapRequestView<'_> {
                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::GetOrderbookHeatmapRequest,
                ::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
            }
            /// Heatmap bucket interval.
            ///
            /// Field 2: `interval`
            #[must_use]
            pub fn interval(&self) -> ::buffa::EnumValue<super::super::HeatmapInterval> {
                self.0.reborrow().interval
            }
            /// Top-N levels per side included in each bucket.
            ///
            /// Field 3: `depth`
            #[must_use]
            pub fn depth(&self) -> ::buffa::EnumValue<super::super::HeatmapDepth> {
                self.0.reborrow().depth
            }
            /// Absolute time range for the first page. Reuse the same request filters and
            /// pass page_token from the prior response to continue older buckets.
            ///
            /// Field 4: `time_range`
            #[must_use]
            pub fn time_range(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapTimeRangeView<'_>,
            > {
                &self.0.reborrow().time_range
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, interval, depth, quantity mode, and the original time
            /// range.
            ///
            /// Field 5: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
            /// Maximum number of delta buckets returned (min 1, max 20000).
            /// This limit counts only `chain.deltas`; `chain.base_keyframe` is not counted.
            ///
            /// Field 6: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Quantity mode used for qty_scaled in snapshot/delta levels:
            /// - CLOSE: end-of-bucket quantity
            /// - PEAK: intra-bucket peak quantity
            ///
            /// Field 7: `quantity_mode`
            #[must_use]
            pub fn quantity_mode(
                &self,
            ) -> ::buffa::EnumValue<super::super::HeatmapQuantityMode> {
                self.0.reborrow().quantity_mode
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>>,
        > for GetOrderbookHeatmapRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>>,
            ) -> Self {
                GetOrderbookHeatmapRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetOrderbookHeatmapRequestOwnedView>
        for ::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>> {
            fn from(wrapper: GetOrderbookHeatmapRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>>,
        > for GetOrderbookHeatmapRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetOrderbookHeatmapRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetOrderbookHeatmapRequest {
            type View<'a> = GetOrderbookHeatmapRequestView<'a>;
            type ViewHandle = GetOrderbookHeatmapRequestOwnedView;
        }
        impl ::serde::Serialize for GetOrderbookHeatmapRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapLevels represents one side of the orderbook for snapshots.
        /// Arrays are aligned by index and prices are sorted ascending for both sides:
        /// - price_ticks\[i\] \<-\> qty_scaled\[i\]
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapLevelsView<'a> {
            /// Price levels in quote units scaled by 1e6.
            ///
            /// Field 1: `price_ticks`
            pub price_ticks: ::buffa::RepeatedView<'a, i64>,
            /// Quantity at each price level according to quantity_mode, scaled by the
            /// pair's base_quantity_scale from GetSpotConfig.
            ///
            /// Field 2: `qty_scaled`
            pub qty_scaled: ::buffa::RepeatedView<'a, i64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapLevelsView<'a> {
            type Owned = super::super::HeatmapLevels;
            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 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.price_ticks
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.price_ticks
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.price_ticks
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    2u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.qty_scaled
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.qty_scaled
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.qty_scaled
                                .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::HeatmapLevels,
                ::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::HeatmapLevels,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapLevels {
                    price_ticks: self.price_ticks.to_vec(),
                    qty_scaled: self.qty_scaled.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapLevelsView<'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.price_ticks.is_empty() {
                    let payload: u32 = self
                        .price_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;
                }
                if !self.qty_scaled.is_empty() {
                    let payload: u32 = self
                        .qty_scaled
                        .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 _;
                if !self.price_ticks.is_empty() {
                    let payload: u32 = self
                        .price_ticks
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(1u32, payload, buf);
                    for &v in &self.price_ticks {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.qty_scaled.is_empty() {
                    let payload: u32 = self
                        .qty_scaled
                        .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.qty_scaled {
                        ::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 HeatmapLevelsView<'__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.price_ticks.is_empty() {
                    __map
                        .serialize_entry(
                            "priceTicks",
                            &::buffa::json_helpers::RepeatedJson(&self.price_ticks),
                        )?;
                }
                if !self.qty_scaled.is_empty() {
                    __map
                        .serialize_entry(
                            "qtyScaled",
                            &::buffa::json_helpers::RepeatedJson(&self.qty_scaled),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapLevelsView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapLevels";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapLevels";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapLevels";
        }
        ::buffa::impl_default_view_instance!(HeatmapLevelsView);
        ::buffa::impl_view_reborrow!(HeatmapLevelsView);
        /** Self-contained, `'static` owned view of a `HeatmapLevels` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapLevelsView`]`<'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 [`HeatmapLevelsView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapLevelsOwnedView(
            ::buffa::OwnedView<HeatmapLevelsView<'static>>,
        );
        impl HeatmapLevelsOwnedView {
            /// 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(
                    HeatmapLevelsOwnedView(::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(
                    HeatmapLevelsOwnedView(
                        ::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::HeatmapLevels,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapLevelsOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapLevelsView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapLevelsView<'_> {
                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::HeatmapLevels,
                ::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()
            }
            /// Price levels in quote units scaled by 1e6.
            ///
            /// Field 1: `price_ticks`
            #[must_use]
            pub fn price_ticks(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().price_ticks
            }
            /// Quantity at each price level according to quantity_mode, scaled by the
            /// pair's base_quantity_scale from GetSpotConfig.
            ///
            /// Field 2: `qty_scaled`
            #[must_use]
            pub fn qty_scaled(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().qty_scaled
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapLevelsView<'static>>>
        for HeatmapLevelsOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapLevelsView<'static>>) -> Self {
                HeatmapLevelsOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapLevelsOwnedView>
        for ::buffa::OwnedView<HeatmapLevelsView<'static>> {
            fn from(wrapper: HeatmapLevelsOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapLevelsView<'static>>>
        for HeatmapLevelsOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapLevelsView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapLevels {
            type View<'a> = HeatmapLevelsView<'a>;
            type ViewHandle = HeatmapLevelsOwnedView;
        }
        impl ::serde::Serialize for HeatmapLevelsOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapDeltaLevels represents sparse per-bucket level changes for one side.
        /// Arrays are aligned by index and prices are sorted ascending for both sides:
        /// - price_ticks\[i\] \<-\> qty_scaled\[i\]
        /// Delete semantics: qty_scaled\[i\] = 0 means delete level at price_ticks\[i\].
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapDeltaLevelsView<'a> {
            /// Price levels in quote units scaled by 1e6.
            ///
            /// Field 1: `price_ticks`
            pub price_ticks: ::buffa::RepeatedView<'a, i64>,
            /// Quantity at each price level, scaled by the pair's base_quantity_scale from
            /// GetSpotConfig. A zero value deletes the level at the matching price_ticks
            /// index.
            ///
            /// Field 2: `qty_scaled`
            pub qty_scaled: ::buffa::RepeatedView<'a, i64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapDeltaLevelsView<'a> {
            type Owned = super::super::HeatmapDeltaLevels;
            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 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.price_ticks
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.price_ticks
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.price_ticks
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    2u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.qty_scaled
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.qty_scaled
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.qty_scaled
                                .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::HeatmapDeltaLevels,
                ::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::HeatmapDeltaLevels,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapDeltaLevels {
                    price_ticks: self.price_ticks.to_vec(),
                    qty_scaled: self.qty_scaled.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapDeltaLevelsView<'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.price_ticks.is_empty() {
                    let payload: u32 = self
                        .price_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;
                }
                if !self.qty_scaled.is_empty() {
                    let payload: u32 = self
                        .qty_scaled
                        .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 _;
                if !self.price_ticks.is_empty() {
                    let payload: u32 = self
                        .price_ticks
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(1u32, payload, buf);
                    for &v in &self.price_ticks {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.qty_scaled.is_empty() {
                    let payload: u32 = self
                        .qty_scaled
                        .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.qty_scaled {
                        ::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 HeatmapDeltaLevelsView<'__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.price_ticks.is_empty() {
                    __map
                        .serialize_entry(
                            "priceTicks",
                            &::buffa::json_helpers::RepeatedJson(&self.price_ticks),
                        )?;
                }
                if !self.qty_scaled.is_empty() {
                    __map
                        .serialize_entry(
                            "qtyScaled",
                            &::buffa::json_helpers::RepeatedJson(&self.qty_scaled),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapDeltaLevelsView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapDeltaLevels";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaLevels";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaLevels";
        }
        ::buffa::impl_default_view_instance!(HeatmapDeltaLevelsView);
        ::buffa::impl_view_reborrow!(HeatmapDeltaLevelsView);
        /** Self-contained, `'static` owned view of a `HeatmapDeltaLevels` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapDeltaLevelsView`]`<'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 [`HeatmapDeltaLevelsView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapDeltaLevelsOwnedView(
            ::buffa::OwnedView<HeatmapDeltaLevelsView<'static>>,
        );
        impl HeatmapDeltaLevelsOwnedView {
            /// 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(
                    HeatmapDeltaLevelsOwnedView(::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(
                    HeatmapDeltaLevelsOwnedView(
                        ::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::HeatmapDeltaLevels,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapDeltaLevelsOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapDeltaLevelsView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapDeltaLevelsView<'_> {
                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::HeatmapDeltaLevels,
                ::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()
            }
            /// Price levels in quote units scaled by 1e6.
            ///
            /// Field 1: `price_ticks`
            #[must_use]
            pub fn price_ticks(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().price_ticks
            }
            /// Quantity at each price level, scaled by the pair's base_quantity_scale from
            /// GetSpotConfig. A zero value deletes the level at the matching price_ticks
            /// index.
            ///
            /// Field 2: `qty_scaled`
            #[must_use]
            pub fn qty_scaled(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().qty_scaled
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapDeltaLevelsView<'static>>>
        for HeatmapDeltaLevelsOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapDeltaLevelsView<'static>>) -> Self {
                HeatmapDeltaLevelsOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapDeltaLevelsOwnedView>
        for ::buffa::OwnedView<HeatmapDeltaLevelsView<'static>> {
            fn from(wrapper: HeatmapDeltaLevelsOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapDeltaLevelsView<'static>>>
        for HeatmapDeltaLevelsOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapDeltaLevelsView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapDeltaLevels {
            type View<'a> = HeatmapDeltaLevelsView<'a>;
            type ViewHandle = HeatmapDeltaLevelsOwnedView;
        }
        impl ::serde::Serialize for HeatmapDeltaLevelsOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapKeyframe is a full-book snapshot anchor.
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapKeyframeView<'a> {
            /// Snapshot timestamp (seconds since epoch, UTC).
            ///
            /// Field 1: `ts_sec`
            pub ts_sec: u64,
            /// Best bid price in quote units scaled by 1e6.
            ///
            /// Field 2: `best_bid_ticks`
            pub best_bid_ticks: i64,
            /// Best ask price in quote units scaled by 1e6.
            ///
            /// Field 3: `best_ask_ticks`
            pub best_ask_ticks: i64,
            /// Mid price in quote units scaled by 1e6.
            ///
            /// Field 4: `mid_ticks`
            pub mid_ticks: i64,
            /// Complete bid-side levels at the snapshot.
            ///
            /// Field 5: `bids`
            pub bids: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLevelsView<'a>,
            >,
            /// Complete ask-side levels at the snapshot.
            ///
            /// Field 6: `asks`
            pub asks: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLevelsView<'a>,
            >,
            /// Monotonic order book sequence at the snapshot.
            ///
            /// Field 7: `book_seq`
            pub book_seq: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapKeyframeView<'a> {
            type Owned = super::super::HeatmapKeyframe;
            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.ts_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_bid_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.best_ask_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.mid_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.bids.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.bids = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.asks.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.asks = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.book_seq = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::HeatmapKeyframe,
                ::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::HeatmapKeyframe,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapKeyframe {
                    ts_sec: self.ts_sec,
                    best_bid_ticks: self.best_bid_ticks,
                    best_ask_ticks: self.best_ask_ticks,
                    mid_ticks: self.mid_ticks,
                    bids: match self.bids.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    asks: match self.asks.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    book_seq: self.book_seq,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapKeyframeView<'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.ts_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
                }
                if self.best_bid_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_bid_ticks)
                                as u32;
                }
                if self.best_ask_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.best_ask_ticks)
                                as u32;
                }
                if self.mid_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.mid_ticks) as u32;
                }
                if self.bids.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.bids.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.asks.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.asks.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.book_seq != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.book_seq) 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.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
                }
                if self.best_bid_ticks != 0i64 {
                    ::buffa::types::put_int64_field(2u32, self.best_bid_ticks, buf);
                }
                if self.best_ask_ticks != 0i64 {
                    ::buffa::types::put_int64_field(3u32, self.best_ask_ticks, buf);
                }
                if self.mid_ticks != 0i64 {
                    ::buffa::types::put_int64_field(4u32, self.mid_ticks, buf);
                }
                if self.bids.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.bids.write_to(__cache, buf);
                }
                if self.asks.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.asks.write_to(__cache, buf);
                }
                if self.book_seq != 0u64 {
                    ::buffa::types::put_uint64_field(7u32, self.book_seq, 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 HeatmapKeyframeView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                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_ask_ticks) {
                    __map
                        .serialize_entry(
                            "bestAskTicks",
                            &::buffa::json_helpers::ProtoJson(&self.best_ask_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.mid_ticks) {
                    __map
                        .serialize_entry(
                            "midTicks",
                            &::buffa::json_helpers::ProtoJson(&self.mid_ticks),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.bids.as_option() {
                        __map.serialize_entry("bids", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.asks.as_option() {
                        __map.serialize_entry("asks", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.book_seq) {
                    __map
                        .serialize_entry(
                            "bookSeq",
                            &::buffa::json_helpers::ProtoJson(&self.book_seq),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapKeyframeView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapKeyframe";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapKeyframe";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapKeyframe";
        }
        ::buffa::impl_default_view_instance!(HeatmapKeyframeView);
        ::buffa::impl_view_reborrow!(HeatmapKeyframeView);
        /** Self-contained, `'static` owned view of a `HeatmapKeyframe` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapKeyframeView`]`<'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 [`HeatmapKeyframeView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapKeyframeOwnedView(
            ::buffa::OwnedView<HeatmapKeyframeView<'static>>,
        );
        impl HeatmapKeyframeOwnedView {
            /// 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(
                    HeatmapKeyframeOwnedView(::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(
                    HeatmapKeyframeOwnedView(
                        ::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::HeatmapKeyframe,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapKeyframeOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapKeyframeView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapKeyframeView<'_> {
                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::HeatmapKeyframe,
                ::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()
            }
            /// Snapshot timestamp (seconds since epoch, UTC).
            ///
            /// Field 1: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
            /// Best bid price in quote units scaled by 1e6.
            ///
            /// Field 2: `best_bid_ticks`
            #[must_use]
            pub fn best_bid_ticks(&self) -> i64 {
                self.0.reborrow().best_bid_ticks
            }
            /// Best ask price in quote units scaled by 1e6.
            ///
            /// Field 3: `best_ask_ticks`
            #[must_use]
            pub fn best_ask_ticks(&self) -> i64 {
                self.0.reborrow().best_ask_ticks
            }
            /// Mid price in quote units scaled by 1e6.
            ///
            /// Field 4: `mid_ticks`
            #[must_use]
            pub fn mid_ticks(&self) -> i64 {
                self.0.reborrow().mid_ticks
            }
            /// Complete bid-side levels at the snapshot.
            ///
            /// Field 5: `bids`
            #[must_use]
            pub fn bids(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLevelsView<'_>,
            > {
                &self.0.reborrow().bids
            }
            /// Complete ask-side levels at the snapshot.
            ///
            /// Field 6: `asks`
            #[must_use]
            pub fn asks(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLevelsView<'_>,
            > {
                &self.0.reborrow().asks
            }
            /// Monotonic order book sequence at the snapshot.
            ///
            /// Field 7: `book_seq`
            #[must_use]
            pub fn book_seq(&self) -> u64 {
                self.0.reborrow().book_seq
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapKeyframeView<'static>>>
        for HeatmapKeyframeOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapKeyframeView<'static>>) -> Self {
                HeatmapKeyframeOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapKeyframeOwnedView>
        for ::buffa::OwnedView<HeatmapKeyframeView<'static>> {
            fn from(wrapper: HeatmapKeyframeOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapKeyframeView<'static>>>
        for HeatmapKeyframeOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapKeyframeView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapKeyframe {
            type View<'a> = HeatmapKeyframeView<'a>;
            type ViewHandle = HeatmapKeyframeOwnedView;
        }
        impl ::serde::Serialize for HeatmapKeyframeOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapDeltaBucket is one sparse update bucket containing both sides.
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapDeltaBucketView<'a> {
            /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
            ///
            /// Field 1: `ts_sec`
            pub ts_sec: u64,
            /// Sparse bid-side level changes in this bucket.
            ///
            /// Field 2: `bids`
            pub bids: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'a>,
            >,
            /// Sparse ask-side level changes in this bucket.
            ///
            /// Field 3: `asks`
            pub asks: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'a>,
            >,
            /// Number of upstream L2 updates aggregated into this interval bucket.
            ///
            /// Field 4: `updates_in_bucket`
            pub updates_in_bucket: u32,
            /// Earliest monotonic order book sequence represented by this bucket.
            ///
            /// Field 5: `book_seq_start`
            pub book_seq_start: u64,
            /// Latest monotonic order book sequence represented by this bucket.
            ///
            /// Field 6: `book_seq_end`
            pub book_seq_end: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapDeltaBucketView<'a> {
            type Owned = super::super::HeatmapDeltaBucket;
            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.ts_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.bids.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.bids = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapDeltaLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.asks.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.asks = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapDeltaLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.updates_in_bucket = ::buffa::types::decode_uint32(
                            &mut cur,
                        )?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.book_seq_start = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.book_seq_end = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::HeatmapDeltaBucket,
                ::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::HeatmapDeltaBucket,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapDeltaBucket {
                    ts_sec: self.ts_sec,
                    bids: match self.bids.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapDeltaLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    asks: match self.asks.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapDeltaLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    updates_in_bucket: self.updates_in_bucket,
                    book_seq_start: self.book_seq_start,
                    book_seq_end: self.book_seq_end,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapDeltaBucketView<'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.ts_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
                }
                if self.bids.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.bids.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.asks.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.asks.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.updates_in_bucket != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.updates_in_bucket)
                                as u32;
                }
                if self.book_seq_start != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.book_seq_start)
                                as u32;
                }
                if self.book_seq_end != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.book_seq_end)
                                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.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
                }
                if self.bids.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.bids.write_to(__cache, buf);
                }
                if self.asks.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.asks.write_to(__cache, buf);
                }
                if self.updates_in_bucket != 0u32 {
                    ::buffa::types::put_uint32_field(4u32, self.updates_in_bucket, buf);
                }
                if self.book_seq_start != 0u64 {
                    ::buffa::types::put_uint64_field(5u32, self.book_seq_start, buf);
                }
                if self.book_seq_end != 0u64 {
                    ::buffa::types::put_uint64_field(6u32, self.book_seq_end, 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 HeatmapDeltaBucketView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.bids.as_option() {
                        __map.serialize_entry("bids", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.asks.as_option() {
                        __map.serialize_entry("asks", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(
                    &self.updates_in_bucket,
                ) {
                    __map
                        .serialize_entry(
                            "updatesInBucket",
                            &::buffa::json_helpers::ProtoJson(&self.updates_in_bucket),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.book_seq_start) {
                    __map
                        .serialize_entry(
                            "bookSeqStart",
                            &::buffa::json_helpers::ProtoJson(&self.book_seq_start),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.book_seq_end) {
                    __map
                        .serialize_entry(
                            "bookSeqEnd",
                            &::buffa::json_helpers::ProtoJson(&self.book_seq_end),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapDeltaBucketView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapDeltaBucket";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaBucket";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaBucket";
        }
        ::buffa::impl_default_view_instance!(HeatmapDeltaBucketView);
        ::buffa::impl_view_reborrow!(HeatmapDeltaBucketView);
        /** Self-contained, `'static` owned view of a `HeatmapDeltaBucket` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapDeltaBucketView`]`<'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 [`HeatmapDeltaBucketView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapDeltaBucketOwnedView(
            ::buffa::OwnedView<HeatmapDeltaBucketView<'static>>,
        );
        impl HeatmapDeltaBucketOwnedView {
            /// 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(
                    HeatmapDeltaBucketOwnedView(::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(
                    HeatmapDeltaBucketOwnedView(
                        ::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::HeatmapDeltaBucket,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapDeltaBucketOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapDeltaBucketView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapDeltaBucketView<'_> {
                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::HeatmapDeltaBucket,
                ::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()
            }
            /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
            ///
            /// Field 1: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
            /// Sparse bid-side level changes in this bucket.
            ///
            /// Field 2: `bids`
            #[must_use]
            pub fn bids(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'_>,
            > {
                &self.0.reborrow().bids
            }
            /// Sparse ask-side level changes in this bucket.
            ///
            /// Field 3: `asks`
            #[must_use]
            pub fn asks(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'_>,
            > {
                &self.0.reborrow().asks
            }
            /// Number of upstream L2 updates aggregated into this interval bucket.
            ///
            /// Field 4: `updates_in_bucket`
            #[must_use]
            pub fn updates_in_bucket(&self) -> u32 {
                self.0.reborrow().updates_in_bucket
            }
            /// Earliest monotonic order book sequence represented by this bucket.
            ///
            /// Field 5: `book_seq_start`
            #[must_use]
            pub fn book_seq_start(&self) -> u64 {
                self.0.reborrow().book_seq_start
            }
            /// Latest monotonic order book sequence represented by this bucket.
            ///
            /// Field 6: `book_seq_end`
            #[must_use]
            pub fn book_seq_end(&self) -> u64 {
                self.0.reborrow().book_seq_end
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapDeltaBucketView<'static>>>
        for HeatmapDeltaBucketOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapDeltaBucketView<'static>>) -> Self {
                HeatmapDeltaBucketOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapDeltaBucketOwnedView>
        for ::buffa::OwnedView<HeatmapDeltaBucketView<'static>> {
            fn from(wrapper: HeatmapDeltaBucketOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapDeltaBucketView<'static>>>
        for HeatmapDeltaBucketOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapDeltaBucketView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapDeltaBucket {
            type View<'a> = HeatmapDeltaBucketView<'a>;
            type ViewHandle = HeatmapDeltaBucketOwnedView;
        }
        impl ::serde::Serialize for HeatmapDeltaBucketOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapLiveBucket is the canonical live payload for real-time heatmap updates.
        /// It represents the latest state of one bucket (open or finalized).
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapLiveBucketView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Bucket interval for this payload.
            ///
            /// Field 2: `interval`
            pub interval: ::buffa::EnumValue<super::super::HeatmapInterval>,
            /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
            ///
            /// Field 3: `ts_sec`
            pub ts_sec: u64,
            /// True when this bucket is finalized; false for provisional updates to an
            /// open bucket.
            ///
            /// Field 4: `is_final`
            pub is_final: bool,
            /// Sparse bid-side level changes represented by this bucket.
            ///
            /// Field 5: `bids`
            pub bids: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'a>,
            >,
            /// Sparse ask-side level changes represented by this bucket.
            ///
            /// Field 6: `asks`
            pub asks: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'a>,
            >,
            /// Number of upstream L2 updates aggregated into this interval bucket.
            ///
            /// Field 7: `updates_in_bucket`
            pub updates_in_bucket: u32,
            /// Earliest monotonic order book sequence represented by this bucket.
            ///
            /// Field 8: `book_seq_start`
            pub book_seq_start: u64,
            /// Latest monotonic order book sequence represented by this bucket.
            ///
            /// Field 9: `book_seq_end`
            pub book_seq_end: u64,
            /// Quantity semantics for qty_scaled in bids and asks.
            ///
            /// Field 10: `quantity_mode`
            pub quantity_mode: ::buffa::EnumValue<super::super::HeatmapQuantityMode>,
            /// Effective bin stride for this symbol as a price delta in 1e-6 quote-unit
            /// ticks.
            ///
            /// Field 11: `effective_bin_ticks`
            pub effective_bin_ticks: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapLiveBucketView<'a> {
            type Owned = super::super::HeatmapLiveBucket;
            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::Varint,
                        )?;
                        view.interval = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.is_final = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.bids.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.bids = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapDeltaLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.asks.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.asks = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapDeltaLevelsView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.updates_in_bucket = ::buffa::types::decode_uint32(
                            &mut cur,
                        )?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.book_seq_start = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.book_seq_end = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    10u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quantity_mode = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    11u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.effective_bin_ticks = ::buffa::types::decode_uint64(
                            &mut cur,
                        )?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::HeatmapLiveBucket,
                ::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::HeatmapLiveBucket,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapLiveBucket {
                    symbol_id: self.symbol_id,
                    interval: self.interval,
                    ts_sec: self.ts_sec,
                    is_final: self.is_final,
                    bids: match self.bids.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapDeltaLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    asks: match self.asks.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapDeltaLevels,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    updates_in_bucket: self.updates_in_bucket,
                    book_seq_start: self.book_seq_start,
                    book_seq_end: self.book_seq_end,
                    quantity_mode: self.quantity_mode,
                    effective_bin_ticks: self.effective_bin_ticks,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for HeatmapLiveBucketView<'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;
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.ts_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
                }
                if self.is_final {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.bids.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.bids.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.asks.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.asks.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.updates_in_bucket != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.updates_in_bucket)
                                as u32;
                }
                if self.book_seq_start != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.book_seq_start)
                                as u32;
                }
                if self.book_seq_end != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.book_seq_end)
                                as u32;
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.effective_bin_ticks != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(
                                self.effective_bin_ticks,
                            ) 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);
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if self.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(3u32, self.ts_sec, buf);
                }
                if self.is_final {
                    ::buffa::types::put_bool_field(4u32, self.is_final, buf);
                }
                if self.bids.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.bids.write_to(__cache, buf);
                }
                if self.asks.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.asks.write_to(__cache, buf);
                }
                if self.updates_in_bucket != 0u32 {
                    ::buffa::types::put_uint32_field(7u32, self.updates_in_bucket, buf);
                }
                if self.book_seq_start != 0u64 {
                    ::buffa::types::put_uint64_field(8u32, self.book_seq_start, buf);
                }
                if self.book_seq_end != 0u64 {
                    ::buffa::types::put_uint64_field(9u32, self.book_seq_end, buf);
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(10u32, val, buf);
                    }
                }
                if self.effective_bin_ticks != 0u64 {
                    ::buffa::types::put_uint64_field(
                        11u32,
                        self.effective_bin_ticks,
                        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 HeatmapLiveBucketView<'__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_default_enum_value(
                    &self.interval,
                ) {
                    __map.serialize_entry("interval", &self.interval)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                if self.is_final {
                    __map.serialize_entry("isFinal", &self.is_final)?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.bids.as_option() {
                        __map.serialize_entry("bids", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.asks.as_option() {
                        __map.serialize_entry("asks", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(
                    &self.updates_in_bucket,
                ) {
                    __map
                        .serialize_entry(
                            "updatesInBucket",
                            &::buffa::json_helpers::ProtoJson(&self.updates_in_bucket),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.book_seq_start) {
                    __map
                        .serialize_entry(
                            "bookSeqStart",
                            &::buffa::json_helpers::ProtoJson(&self.book_seq_start),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.book_seq_end) {
                    __map
                        .serialize_entry(
                            "bookSeqEnd",
                            &::buffa::json_helpers::ProtoJson(&self.book_seq_end),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.quantity_mode,
                ) {
                    __map.serialize_entry("quantityMode", &self.quantity_mode)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(
                    &self.effective_bin_ticks,
                ) {
                    __map
                        .serialize_entry(
                            "effectiveBinTicks",
                            &::buffa::json_helpers::ProtoJson(&self.effective_bin_ticks),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapLiveBucketView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapLiveBucket";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapLiveBucket";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapLiveBucket";
        }
        ::buffa::impl_default_view_instance!(HeatmapLiveBucketView);
        ::buffa::impl_view_reborrow!(HeatmapLiveBucketView);
        /** Self-contained, `'static` owned view of a `HeatmapLiveBucket` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapLiveBucketView`]`<'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 [`HeatmapLiveBucketView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapLiveBucketOwnedView(
            ::buffa::OwnedView<HeatmapLiveBucketView<'static>>,
        );
        impl HeatmapLiveBucketOwnedView {
            /// 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(
                    HeatmapLiveBucketOwnedView(::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(
                    HeatmapLiveBucketOwnedView(
                        ::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::HeatmapLiveBucket,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapLiveBucketOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapLiveBucketView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapLiveBucketView<'_> {
                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::HeatmapLiveBucket,
                ::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
            }
            /// Bucket interval for this payload.
            ///
            /// Field 2: `interval`
            #[must_use]
            pub fn interval(&self) -> ::buffa::EnumValue<super::super::HeatmapInterval> {
                self.0.reborrow().interval
            }
            /// Bucket start timestamp (seconds since epoch, UTC), aligned to `interval`.
            ///
            /// Field 3: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
            /// True when this bucket is finalized; false for provisional updates to an
            /// open bucket.
            ///
            /// Field 4: `is_final`
            #[must_use]
            pub fn is_final(&self) -> bool {
                self.0.reborrow().is_final
            }
            /// Sparse bid-side level changes represented by this bucket.
            ///
            /// Field 5: `bids`
            #[must_use]
            pub fn bids(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'_>,
            > {
                &self.0.reborrow().bids
            }
            /// Sparse ask-side level changes represented by this bucket.
            ///
            /// Field 6: `asks`
            #[must_use]
            pub fn asks(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaLevelsView<'_>,
            > {
                &self.0.reborrow().asks
            }
            /// Number of upstream L2 updates aggregated into this interval bucket.
            ///
            /// Field 7: `updates_in_bucket`
            #[must_use]
            pub fn updates_in_bucket(&self) -> u32 {
                self.0.reborrow().updates_in_bucket
            }
            /// Earliest monotonic order book sequence represented by this bucket.
            ///
            /// Field 8: `book_seq_start`
            #[must_use]
            pub fn book_seq_start(&self) -> u64 {
                self.0.reborrow().book_seq_start
            }
            /// Latest monotonic order book sequence represented by this bucket.
            ///
            /// Field 9: `book_seq_end`
            #[must_use]
            pub fn book_seq_end(&self) -> u64 {
                self.0.reborrow().book_seq_end
            }
            /// Quantity semantics for qty_scaled in bids and asks.
            ///
            /// Field 10: `quantity_mode`
            #[must_use]
            pub fn quantity_mode(
                &self,
            ) -> ::buffa::EnumValue<super::super::HeatmapQuantityMode> {
                self.0.reborrow().quantity_mode
            }
            /// Effective bin stride for this symbol as a price delta in 1e-6 quote-unit
            /// ticks.
            ///
            /// Field 11: `effective_bin_ticks`
            #[must_use]
            pub fn effective_bin_ticks(&self) -> u64 {
                self.0.reborrow().effective_bin_ticks
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapLiveBucketView<'static>>>
        for HeatmapLiveBucketOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapLiveBucketView<'static>>) -> Self {
                HeatmapLiveBucketOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapLiveBucketOwnedView>
        for ::buffa::OwnedView<HeatmapLiveBucketView<'static>> {
            fn from(wrapper: HeatmapLiveBucketOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapLiveBucketView<'static>>>
        for HeatmapLiveBucketOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapLiveBucketView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapLiveBucket {
            type View<'a> = HeatmapLiveBucketView<'a>;
            type ViewHandle = HeatmapLiveBucketOwnedView;
        }
        impl ::serde::Serialize for HeatmapLiveBucketOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// HeatmapDeltaChain is the historical payload for all intervals.
        /// Reconstruct by applying deltas over base_keyframe.
        /// Deltas are ordered oldest-first by ts_sec.
        #[derive(Clone, Debug, Default)]
        pub struct HeatmapDeltaChainView<'a> {
            /// Full-book snapshot from which to apply the returned deltas.
            ///
            /// Field 1: `base_keyframe`
            pub base_keyframe: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapKeyframeView<'a>,
            >,
            /// Sparse update buckets ordered oldest-first by timestamp.
            ///
            /// Field 2: `deltas`
            pub deltas: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::HeatmapDeltaBucketView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for HeatmapDeltaChainView<'a> {
            type Owned = super::super::HeatmapDeltaChain;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.base_keyframe.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.base_keyframe = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapKeyframeView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.deltas
                            .push(
                                <super::super::__buffa::view::HeatmapDeltaBucketView 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::HeatmapDeltaChain,
                ::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::HeatmapDeltaChain,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::HeatmapDeltaChain {
                    base_keyframe: match self.base_keyframe.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapKeyframe,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    deltas: self
                        .deltas
                        .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 HeatmapDeltaChainView<'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.base_keyframe.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.base_keyframe.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                for v in &self.deltas {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.base_keyframe.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.base_keyframe.write_to(__cache, buf);
                }
                for v in &self.deltas {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for HeatmapDeltaChainView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                {
                    if let ::core::option::Option::Some(__v) = self
                        .base_keyframe
                        .as_option()
                    {
                        __map.serialize_entry("baseKeyframe", __v)?;
                    }
                }
                if !self.deltas.is_empty() {
                    __map.serialize_entry("deltas", &*self.deltas)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for HeatmapDeltaChainView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "HeatmapDeltaChain";
            const FULL_NAME: &'static str = "marketdata.v1.HeatmapDeltaChain";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.HeatmapDeltaChain";
        }
        ::buffa::impl_default_view_instance!(HeatmapDeltaChainView);
        ::buffa::impl_view_reborrow!(HeatmapDeltaChainView);
        /** Self-contained, `'static` owned view of a `HeatmapDeltaChain` message.

 Wraps [`::buffa::OwnedView`]`<`[`HeatmapDeltaChainView`]`<'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 [`HeatmapDeltaChainView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct HeatmapDeltaChainOwnedView(
            ::buffa::OwnedView<HeatmapDeltaChainView<'static>>,
        );
        impl HeatmapDeltaChainOwnedView {
            /// 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(
                    HeatmapDeltaChainOwnedView(::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(
                    HeatmapDeltaChainOwnedView(
                        ::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::HeatmapDeltaChain,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    HeatmapDeltaChainOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`HeatmapDeltaChainView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &HeatmapDeltaChainView<'_> {
                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::HeatmapDeltaChain,
                ::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()
            }
            /// Full-book snapshot from which to apply the returned deltas.
            ///
            /// Field 1: `base_keyframe`
            #[must_use]
            pub fn base_keyframe(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapKeyframeView<'_>,
            > {
                &self.0.reborrow().base_keyframe
            }
            /// Sparse update buckets ordered oldest-first by timestamp.
            ///
            /// Field 2: `deltas`
            #[must_use]
            pub fn deltas(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::HeatmapDeltaBucketView<'_>,
            > {
                &self.0.reborrow().deltas
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<HeatmapDeltaChainView<'static>>>
        for HeatmapDeltaChainOwnedView {
            fn from(inner: ::buffa::OwnedView<HeatmapDeltaChainView<'static>>) -> Self {
                HeatmapDeltaChainOwnedView(inner)
            }
        }
        impl ::core::convert::From<HeatmapDeltaChainOwnedView>
        for ::buffa::OwnedView<HeatmapDeltaChainView<'static>> {
            fn from(wrapper: HeatmapDeltaChainOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<HeatmapDeltaChainView<'static>>>
        for HeatmapDeltaChainOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<HeatmapDeltaChainView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::HeatmapDeltaChain {
            type View<'a> = HeatmapDeltaChainView<'a>;
            type ViewHandle = HeatmapDeltaChainOwnedView;
        }
        impl ::serde::Serialize for HeatmapDeltaChainOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetOrderbookHeatmapResponse returns a historical replay chain plus optional
        /// live bucket state for explicit realtime stitching.
        #[derive(Clone, Debug, Default)]
        pub struct GetOrderbookHeatmapResponseView<'a> {
            /// Numeric spot market identifier returned for the requested market.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Bucket interval used for the returned chain.
            ///
            /// Field 2: `interval`
            pub interval: ::buffa::EnumValue<super::super::HeatmapInterval>,
            /// Top-N depth requested per side.
            ///
            /// Field 3: `depth`
            pub depth: ::buffa::EnumValue<super::super::HeatmapDepth>,
            /// Always returned as snapshot + sparse deltas for the requested interval.
            ///
            /// Field 4: `chain`
            pub chain: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaChainView<'a>,
            >,
            /// Latest finalized historical bucket timestamp in seconds since epoch (UTC).
            ///
            /// Field 5: `last_persisted_ts_sec`
            pub last_persisted_ts_sec: u64,
            /// Book sequence anchor for realtime continuation; apply live updates where book_seq_end is greater than this value.
            ///
            /// Field 6: `live_from_book_seq_end`
            pub live_from_book_seq_end: u64,
            /// True when live_from_book_seq_end is available and can be used as a realtime continuation anchor.
            ///
            /// Field 7: `has_live_anchor`
            pub has_live_anchor: bool,
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 8: `next_page_token`
            pub next_page_token: &'a str,
            /// Server response time in seconds since epoch (UTC).
            ///
            /// Field 10: `server_time_sec`
            pub server_time_sec: u64,
            /// Quantity mode used for all qty_scaled values in the response.
            ///
            /// Field 11: `quantity_mode`
            pub quantity_mode: ::buffa::EnumValue<super::super::HeatmapQuantityMode>,
            /// Optional latest live bucket for the requested interval and depth.
            /// Present only when it is newer than the historical anchor and its quantity semantics match quantity_mode.
            ///
            /// Field 12: `live_bucket`
            pub live_bucket: ::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLiveBucketView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetOrderbookHeatmapResponseView<'a> {
            type Owned = super::super::GetOrderbookHeatmapResponse;
            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::Varint,
                        )?;
                        view.interval = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.depth = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.chain.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.chain = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapDeltaChainView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.last_persisted_ts_sec = ::buffa::types::decode_uint64(
                            &mut cur,
                        )?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.live_from_book_seq_end = ::buffa::types::decode_uint64(
                            &mut cur,
                        )?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.has_live_anchor = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.next_page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    10u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.server_time_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    11u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quantity_mode = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    12u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.live_bucket.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.live_bucket = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::HeatmapLiveBucketView 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::GetOrderbookHeatmapResponse,
                ::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::GetOrderbookHeatmapResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetOrderbookHeatmapResponse {
                    symbol_id: self.symbol_id,
                    interval: self.interval,
                    depth: self.depth,
                    chain: match self.chain.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapDeltaChain,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    last_persisted_ts_sec: self.last_persisted_ts_sec,
                    live_from_book_seq_end: self.live_from_book_seq_end,
                    has_live_anchor: self.has_live_anchor,
                    next_page_token: self.next_page_token.to_string(),
                    server_time_sec: self.server_time_sec,
                    quantity_mode: self.quantity_mode,
                    live_bucket: match self.live_bucket.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::HeatmapLiveBucket,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetOrderbookHeatmapResponseView<'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;
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                {
                    let val = self.depth.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.chain.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.chain.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.last_persisted_ts_sec != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(
                                self.last_persisted_ts_sec,
                            ) as u32;
                }
                if self.live_from_book_seq_end != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(
                                self.live_from_book_seq_end,
                            ) as u32;
                }
                if self.has_live_anchor {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if !self.next_page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.next_page_token)
                                as u32;
                }
                if self.server_time_sec != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.server_time_sec)
                                as u32;
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.live_bucket.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.live_bucket.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.interval.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                {
                    let val = self.depth.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(3u32, val, buf);
                    }
                }
                if self.chain.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.chain.write_to(__cache, buf);
                }
                if self.last_persisted_ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(
                        5u32,
                        self.last_persisted_ts_sec,
                        buf,
                    );
                }
                if self.live_from_book_seq_end != 0u64 {
                    ::buffa::types::put_uint64_field(
                        6u32,
                        self.live_from_book_seq_end,
                        buf,
                    );
                }
                if self.has_live_anchor {
                    ::buffa::types::put_bool_field(7u32, self.has_live_anchor, buf);
                }
                if !self.next_page_token.is_empty() {
                    ::buffa::types::put_string_field(8u32, &self.next_page_token, buf);
                }
                if self.server_time_sec != 0u64 {
                    ::buffa::types::put_uint64_field(10u32, self.server_time_sec, buf);
                }
                {
                    let val = self.quantity_mode.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(11u32, val, buf);
                    }
                }
                if self.live_bucket.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        12u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.live_bucket.write_to(__cache, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for GetOrderbookHeatmapResponseView<'__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_default_enum_value(
                    &self.interval,
                ) {
                    __map.serialize_entry("interval", &self.interval)?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.depth) {
                    __map.serialize_entry("depth", &self.depth)?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self.chain.as_option() {
                        __map.serialize_entry("chain", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(
                    &self.last_persisted_ts_sec,
                ) {
                    __map
                        .serialize_entry(
                            "lastPersistedTsSec",
                            &::buffa::json_helpers::ProtoJson(
                                &self.last_persisted_ts_sec,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(
                    &self.live_from_book_seq_end,
                ) {
                    __map
                        .serialize_entry(
                            "liveFromBookSeqEnd",
                            &::buffa::json_helpers::ProtoJson(
                                &self.live_from_book_seq_end,
                            ),
                        )?;
                }
                if self.has_live_anchor {
                    __map.serialize_entry("hasLiveAnchor", &self.has_live_anchor)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.next_page_token) {
                    __map.serialize_entry("nextPageToken", self.next_page_token)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.server_time_sec) {
                    __map
                        .serialize_entry(
                            "serverTimeSec",
                            &::buffa::json_helpers::ProtoJson(&self.server_time_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(
                    &self.quantity_mode,
                ) {
                    __map.serialize_entry("quantityMode", &self.quantity_mode)?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .live_bucket
                        .as_option()
                    {
                        __map.serialize_entry("liveBucket", __v)?;
                    }
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetOrderbookHeatmapResponseView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetOrderbookHeatmapResponse";
            const FULL_NAME: &'static str = "marketdata.v1.GetOrderbookHeatmapResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetOrderbookHeatmapResponse";
        }
        ::buffa::impl_default_view_instance!(GetOrderbookHeatmapResponseView);
        ::buffa::impl_view_reborrow!(GetOrderbookHeatmapResponseView);
        /** Self-contained, `'static` owned view of a `GetOrderbookHeatmapResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetOrderbookHeatmapResponseView`]`<'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 [`GetOrderbookHeatmapResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetOrderbookHeatmapResponseOwnedView(
            ::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>>,
        );
        impl GetOrderbookHeatmapResponseOwnedView {
            /// 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(
                    GetOrderbookHeatmapResponseOwnedView(
                        ::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(
                    GetOrderbookHeatmapResponseOwnedView(
                        ::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::GetOrderbookHeatmapResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetOrderbookHeatmapResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetOrderbookHeatmapResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetOrderbookHeatmapResponseView<'_> {
                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::GetOrderbookHeatmapResponse,
                ::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 returned for the requested market.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Bucket interval used for the returned chain.
            ///
            /// Field 2: `interval`
            #[must_use]
            pub fn interval(&self) -> ::buffa::EnumValue<super::super::HeatmapInterval> {
                self.0.reborrow().interval
            }
            /// Top-N depth requested per side.
            ///
            /// Field 3: `depth`
            #[must_use]
            pub fn depth(&self) -> ::buffa::EnumValue<super::super::HeatmapDepth> {
                self.0.reborrow().depth
            }
            /// Always returned as snapshot + sparse deltas for the requested interval.
            ///
            /// Field 4: `chain`
            #[must_use]
            pub fn chain(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapDeltaChainView<'_>,
            > {
                &self.0.reborrow().chain
            }
            /// Latest finalized historical bucket timestamp in seconds since epoch (UTC).
            ///
            /// Field 5: `last_persisted_ts_sec`
            #[must_use]
            pub fn last_persisted_ts_sec(&self) -> u64 {
                self.0.reborrow().last_persisted_ts_sec
            }
            /// Book sequence anchor for realtime continuation; apply live updates where book_seq_end is greater than this value.
            ///
            /// Field 6: `live_from_book_seq_end`
            #[must_use]
            pub fn live_from_book_seq_end(&self) -> u64 {
                self.0.reborrow().live_from_book_seq_end
            }
            /// True when live_from_book_seq_end is available and can be used as a realtime continuation anchor.
            ///
            /// Field 7: `has_live_anchor`
            #[must_use]
            pub fn has_live_anchor(&self) -> bool {
                self.0.reborrow().has_live_anchor
            }
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 8: `next_page_token`
            #[must_use]
            pub fn next_page_token(&self) -> &'_ str {
                self.0.reborrow().next_page_token
            }
            /// Server response time in seconds since epoch (UTC).
            ///
            /// Field 10: `server_time_sec`
            #[must_use]
            pub fn server_time_sec(&self) -> u64 {
                self.0.reborrow().server_time_sec
            }
            /// Quantity mode used for all qty_scaled values in the response.
            ///
            /// Field 11: `quantity_mode`
            #[must_use]
            pub fn quantity_mode(
                &self,
            ) -> ::buffa::EnumValue<super::super::HeatmapQuantityMode> {
                self.0.reborrow().quantity_mode
            }
            /// Optional latest live bucket for the requested interval and depth.
            /// Present only when it is newer than the historical anchor and its quantity semantics match quantity_mode.
            ///
            /// Field 12: `live_bucket`
            #[must_use]
            pub fn live_bucket(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::HeatmapLiveBucketView<'_>,
            > {
                &self.0.reborrow().live_bucket
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>>,
        > for GetOrderbookHeatmapResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>>,
            ) -> Self {
                GetOrderbookHeatmapResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetOrderbookHeatmapResponseOwnedView>
        for ::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>> {
            fn from(wrapper: GetOrderbookHeatmapResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>>,
        > for GetOrderbookHeatmapResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetOrderbookHeatmapResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetOrderbookHeatmapResponse {
            type View<'a> = GetOrderbookHeatmapResponseView<'a>;
            type ViewHandle = GetOrderbookHeatmapResponseOwnedView;
        }
        impl ::serde::Serialize for GetOrderbookHeatmapResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ---------------------------------------------------------------------------
        /// GetTrades: Binary (protobuf) request/response with scaled integers.
        /// REST responses expose decimal strings.
        /// ---------------------------------------------------------------------------
        ///
        /// GetTradesRequest selects recent public trades for one spot market.
        ///
        /// Results are ordered newest-first by execution timestamp, with match_id as a
        /// tie-breaker. When both start_time and end_time are set, both bounds are
        /// inclusive.
        #[derive(Clone, Debug, Default)]
        pub struct GetTradesRequestView<'a> {
            /// Stable numeric pair id from GetSpotConfig.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Maximum number of trades to return. Defaults to 100 when unset; max 1000.
            ///
            /// Field 2: `limit`
            pub limit: u32,
            /// Inclusive lower bound for trade execution time. Must not be more than
            /// 5 minutes in the future.
            ///
            /// Field 3: `start_time`
            pub start_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Inclusive upper bound for trade execution time. Must be greater than or
            /// equal to start_time when both are set, and must not be more than 5 minutes
            /// in the future.
            ///
            /// Field 4: `end_time`
            pub end_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Optional filter by trade aggressor side. Unspecified returns both sides.
            ///
            /// Field 5: `side`
            pub side: ::buffa::EnumValue<super::super::SideFilter>,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, time bounds, side filter, and newest-first sort order.
            ///
            /// Field 6: `page_token`
            pub page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetTradesRequestView<'a> {
            type Owned = super::super::GetTradesRequest;
            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::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.start_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.start_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.end_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.end_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.side = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::GetTradesRequest,
                ::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::GetTradesRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetTradesRequest {
                    symbol_id: self.symbol_id,
                    limit: self.limit,
                    start_time: match self.start_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    end_time: match self.end_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    side: self.side,
                    page_token: self.page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetTradesRequestView<'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.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if self.start_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.start_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.end_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.end_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                {
                    let val = self.side.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.limit, buf);
                }
                if self.start_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.start_time.write_to(__cache, buf);
                }
                if self.end_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.end_time.write_to(__cache, buf);
                }
                {
                    let val = self.side.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(5u32, val, buf);
                    }
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(6u32, &self.page_token, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for GetTradesRequestView<'__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_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .start_time
                        .as_option()
                    {
                        __map.serialize_entry("startTime", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.end_time.as_option()
                    {
                        __map.serialize_entry("endTime", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.side) {
                    __map.serialize_entry("side", &self.side)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetTradesRequestView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetTradesRequest";
            const FULL_NAME: &'static str = "marketdata.v1.GetTradesRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetTradesRequest";
        }
        ::buffa::impl_default_view_instance!(GetTradesRequestView);
        ::buffa::impl_view_reborrow!(GetTradesRequestView);
        /** Self-contained, `'static` owned view of a `GetTradesRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetTradesRequestView`]`<'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 [`GetTradesRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetTradesRequestOwnedView(
            ::buffa::OwnedView<GetTradesRequestView<'static>>,
        );
        impl GetTradesRequestOwnedView {
            /// 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(
                    GetTradesRequestOwnedView(::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(
                    GetTradesRequestOwnedView(
                        ::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::GetTradesRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetTradesRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetTradesRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetTradesRequestView<'_> {
                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::GetTradesRequest,
                ::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 numeric pair id from GetSpotConfig.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Maximum number of trades to return. Defaults to 100 when unset; max 1000.
            ///
            /// Field 2: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Inclusive lower bound for trade execution time. Must not be more than
            /// 5 minutes in the future.
            ///
            /// Field 3: `start_time`
            #[must_use]
            pub fn start_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().start_time
            }
            /// Inclusive upper bound for trade execution time. Must be greater than or
            /// equal to start_time when both are set, and must not be more than 5 minutes
            /// in the future.
            ///
            /// Field 4: `end_time`
            #[must_use]
            pub fn end_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().end_time
            }
            /// Optional filter by trade aggressor side. Unspecified returns both sides.
            ///
            /// Field 5: `side`
            #[must_use]
            pub fn side(&self) -> ::buffa::EnumValue<super::super::SideFilter> {
                self.0.reborrow().side
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, time bounds, side filter, and newest-first sort order.
            ///
            /// Field 6: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetTradesRequestView<'static>>>
        for GetTradesRequestOwnedView {
            fn from(inner: ::buffa::OwnedView<GetTradesRequestView<'static>>) -> Self {
                GetTradesRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetTradesRequestOwnedView>
        for ::buffa::OwnedView<GetTradesRequestView<'static>> {
            fn from(wrapper: GetTradesRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetTradesRequestView<'static>>>
        for GetTradesRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetTradesRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetTradesRequest {
            type View<'a> = GetTradesRequestView<'a>;
            type ViewHandle = GetTradesRequestOwnedView;
        }
        impl ::serde::Serialize for GetTradesRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// MarketTrade is one public trade print represented with scaled integers.
        ///
        /// REST responses render price and quantity as decimal strings.
        #[derive(Clone, Debug, Default)]
        pub struct MarketTradeView<'a> {
            /// Stable numeric pair id from GetSpotConfig.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Stable trade id within the symbol, suitable for pagination and de-duplication.
            ///
            /// Field 2: `match_id`
            pub match_id: u64,
            /// True when the taker/aggressor bought the base asset; false when the
            /// taker/aggressor sold the base asset.
            ///
            /// Field 3: `is_buy`
            pub is_buy: bool,
            /// Trade price in quote-asset units scaled by 1e6.
            ///
            /// Field 4: `price_ticks`
            pub price_ticks: i64,
            /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 5: `qty_scaled`
            pub qty_scaled: i64,
            /// Trade execution timestamp, in nanoseconds since the Unix epoch (UTC).
            ///
            /// Field 6: `ts_ns`
            pub ts_ns: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for MarketTradeView<'a> {
            type Owned = super::super::MarketTrade;
            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::Varint,
                        )?;
                        view.match_id = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.is_buy = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.price_ticks = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.qty_scaled = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_ns = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::MarketTrade,
                ::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::MarketTrade,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::MarketTrade {
                    symbol_id: self.symbol_id,
                    match_id: self.match_id,
                    is_buy: self.is_buy,
                    price_ticks: self.price_ticks,
                    qty_scaled: self.qty_scaled,
                    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 MarketTradeView<'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.match_id != 0u64 {
                    size
                        += 1u32
                            + ::buffa::types::uint64_encoded_len(self.match_id) as u32;
                }
                if self.is_buy {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.price_ticks != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.price_ticks) as u32;
                }
                if self.qty_scaled != 0i64 {
                    size
                        += 1u32
                            + ::buffa::types::int64_encoded_len(self.qty_scaled) as u32;
                }
                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 _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                if self.match_id != 0u64 {
                    ::buffa::types::put_uint64_field(2u32, self.match_id, buf);
                }
                if self.is_buy {
                    ::buffa::types::put_bool_field(3u32, self.is_buy, buf);
                }
                if self.price_ticks != 0i64 {
                    ::buffa::types::put_int64_field(4u32, self.price_ticks, buf);
                }
                if self.qty_scaled != 0i64 {
                    ::buffa::types::put_int64_field(5u32, self.qty_scaled, buf);
                }
                if self.ts_ns != 0u64 {
                    ::buffa::types::put_uint64_field(6u32, 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 MarketTradeView<'__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_zero_u64(&self.match_id) {
                    __map
                        .serialize_entry(
                            "matchId",
                            &::buffa::json_helpers::ProtoJson(&self.match_id),
                        )?;
                }
                if self.is_buy {
                    __map.serialize_entry("isBuy", &self.is_buy)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.price_ticks) {
                    __map
                        .serialize_entry(
                            "priceTicks",
                            &::buffa::json_helpers::ProtoJson(&self.price_ticks),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.qty_scaled) {
                    __map
                        .serialize_entry(
                            "qtyScaled",
                            &::buffa::json_helpers::ProtoJson(&self.qty_scaled),
                        )?;
                }
                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 MarketTradeView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "MarketTrade";
            const FULL_NAME: &'static str = "marketdata.v1.MarketTrade";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.MarketTrade";
        }
        ::buffa::impl_default_view_instance!(MarketTradeView);
        ::buffa::impl_view_reborrow!(MarketTradeView);
        /** Self-contained, `'static` owned view of a `MarketTrade` message.

 Wraps [`::buffa::OwnedView`]`<`[`MarketTradeView`]`<'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 [`MarketTradeView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct MarketTradeOwnedView(::buffa::OwnedView<MarketTradeView<'static>>);
        impl MarketTradeOwnedView {
            /// 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(
                    MarketTradeOwnedView(::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(
                    MarketTradeOwnedView(
                        ::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::MarketTrade,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    MarketTradeOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`MarketTradeView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &MarketTradeView<'_> {
                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::MarketTrade,
                ::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 numeric pair id from GetSpotConfig.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Stable trade id within the symbol, suitable for pagination and de-duplication.
            ///
            /// Field 2: `match_id`
            #[must_use]
            pub fn match_id(&self) -> u64 {
                self.0.reborrow().match_id
            }
            /// True when the taker/aggressor bought the base asset; false when the
            /// taker/aggressor sold the base asset.
            ///
            /// Field 3: `is_buy`
            #[must_use]
            pub fn is_buy(&self) -> bool {
                self.0.reborrow().is_buy
            }
            /// Trade price in quote-asset units scaled by 1e6.
            ///
            /// Field 4: `price_ticks`
            #[must_use]
            pub fn price_ticks(&self) -> i64 {
                self.0.reborrow().price_ticks
            }
            /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 5: `qty_scaled`
            #[must_use]
            pub fn qty_scaled(&self) -> i64 {
                self.0.reborrow().qty_scaled
            }
            /// Trade execution timestamp, in nanoseconds since the Unix epoch (UTC).
            ///
            /// Field 6: `ts_ns`
            #[must_use]
            pub fn ts_ns(&self) -> u64 {
                self.0.reborrow().ts_ns
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<MarketTradeView<'static>>>
        for MarketTradeOwnedView {
            fn from(inner: ::buffa::OwnedView<MarketTradeView<'static>>) -> Self {
                MarketTradeOwnedView(inner)
            }
        }
        impl ::core::convert::From<MarketTradeOwnedView>
        for ::buffa::OwnedView<MarketTradeView<'static>> {
            fn from(wrapper: MarketTradeOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<MarketTradeView<'static>>>
        for MarketTradeOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<MarketTradeView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::MarketTrade {
            type View<'a> = MarketTradeView<'a>;
            type ViewHandle = MarketTradeOwnedView;
        }
        impl ::serde::Serialize for MarketTradeOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetTradesResponse contains public trades for one spot market.
        #[derive(Clone, Debug, Default)]
        pub struct GetTradesResponseView<'a> {
            /// Trades ordered newest-first by execution timestamp, with match_id as a
            /// tie-breaker.
            ///
            /// Field 1: `trades`
            pub trades: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::MarketTradeView<'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 GetTradesResponseView<'a> {
            type Owned = super::super::GetTradesResponse;
            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.trades
                            .push(
                                <super::super::__buffa::view::MarketTradeView 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::GetTradesResponse,
                ::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::GetTradesResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetTradesResponse {
                    trades: self
                        .trades
                        .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 GetTradesResponseView<'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.trades {
                    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.trades {
                    ::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 GetTradesResponseView<'__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.trades.is_empty() {
                    __map.serialize_entry("trades", &*self.trades)?;
                }
                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 GetTradesResponseView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetTradesResponse";
            const FULL_NAME: &'static str = "marketdata.v1.GetTradesResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetTradesResponse";
        }
        ::buffa::impl_default_view_instance!(GetTradesResponseView);
        ::buffa::impl_view_reborrow!(GetTradesResponseView);
        /** Self-contained, `'static` owned view of a `GetTradesResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetTradesResponseView`]`<'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 [`GetTradesResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetTradesResponseOwnedView(
            ::buffa::OwnedView<GetTradesResponseView<'static>>,
        );
        impl GetTradesResponseOwnedView {
            /// 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(
                    GetTradesResponseOwnedView(::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(
                    GetTradesResponseOwnedView(
                        ::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::GetTradesResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetTradesResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetTradesResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetTradesResponseView<'_> {
                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::GetTradesResponse,
                ::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()
            }
            /// Trades ordered newest-first by execution timestamp, with match_id as a
            /// tie-breaker.
            ///
            /// Field 1: `trades`
            #[must_use]
            pub fn trades(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::MarketTradeView<'_>,
            > {
                &self.0.reborrow().trades
            }
            /// 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<GetTradesResponseView<'static>>>
        for GetTradesResponseOwnedView {
            fn from(inner: ::buffa::OwnedView<GetTradesResponseView<'static>>) -> Self {
                GetTradesResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetTradesResponseOwnedView>
        for ::buffa::OwnedView<GetTradesResponseView<'static>> {
            fn from(wrapper: GetTradesResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetTradesResponseView<'static>>>
        for GetTradesResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetTradesResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetTradesResponse {
            type View<'a> = GetTradesResponseView<'a>;
            type ViewHandle = GetTradesResponseOwnedView;
        }
        impl ::serde::Serialize for GetTradesResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ---------------------------------------------------------------------------
        /// GetCandles: Binary (protobuf) request/response with scaled integers.
        /// REST responses expose decimal strings.
        /// ---------------------------------------------------------------------------
        ///
        /// GetCandlesRequest selects a spot market candle series.
        ///
        /// The response is ordered newest-first by candle bucket start time. When both
        /// start_time and end_time are set, both bounds are inclusive.
        #[derive(Clone, Debug, Default)]
        pub struct GetCandlesRequestView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Candle bucket size. Required for ConnectRPC clients.
            ///
            /// Field 2: `timeframe`
            pub timeframe: ::buffa::EnumValue<super::super::Timeframe>,
            /// Maximum number of closed candles to return. Defaults to 500 when unset;
            /// max 10000.
            ///
            /// Field 3: `limit`
            pub limit: u32,
            /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
            /// Must not be more than 5 minutes in the future.
            ///
            /// Field 4: `start_time`
            pub start_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
            /// Must be greater than or equal to start_time when both are set, and must not
            /// be more than 5 minutes in the future.
            ///
            /// Field 5: `end_time`
            pub end_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Include the current open candle when it is available and inside the
            /// requested range.
            /// The open candle is prepended to the newest-first candle list and does not
            /// count toward the closed-candle limit.
            ///
            /// Field 6: `include_incomplete`
            pub include_incomplete: bool,
            /// Include the composite reference market candle series for the same market,
            /// timeframe, and time range.
            /// The reference series can be empty when no reference series is available for
            /// the requested timeframe.
            ///
            /// Field 7: `include_reference`
            pub include_reference: bool,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, timeframe, time bounds, and newest-first candle ordering.
            /// Inclusion flags affect response enrichment and may change between pages.
            ///
            /// Field 8: `page_token`
            pub page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetCandlesRequestView<'a> {
            type Owned = super::super::GetCandlesRequest;
            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::Varint,
                        )?;
                        view.timeframe = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.start_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.start_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.end_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.end_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.include_incomplete = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.include_reference = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::GetCandlesRequest,
                ::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::GetCandlesRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetCandlesRequest {
                    symbol_id: self.symbol_id,
                    timeframe: self.timeframe,
                    limit: self.limit,
                    start_time: match self.start_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    end_time: match self.end_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    include_incomplete: self.include_incomplete,
                    include_reference: self.include_reference,
                    page_token: self.page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetCandlesRequestView<'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;
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if self.start_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.start_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.end_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.end_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.include_incomplete {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.include_reference {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(3u32, self.limit, buf);
                }
                if self.start_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.start_time.write_to(__cache, buf);
                }
                if self.end_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.end_time.write_to(__cache, buf);
                }
                if self.include_incomplete {
                    ::buffa::types::put_bool_field(6u32, self.include_incomplete, buf);
                }
                if self.include_reference {
                    ::buffa::types::put_bool_field(7u32, self.include_reference, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(8u32, &self.page_token, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for GetCandlesRequestView<'__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_default_enum_value(
                    &self.timeframe,
                ) {
                    __map.serialize_entry("timeframe", &self.timeframe)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .start_time
                        .as_option()
                    {
                        __map.serialize_entry("startTime", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.end_time.as_option()
                    {
                        __map.serialize_entry("endTime", __v)?;
                    }
                }
                if self.include_incomplete {
                    __map
                        .serialize_entry("includeIncomplete", &self.include_incomplete)?;
                }
                if self.include_reference {
                    __map.serialize_entry("includeReference", &self.include_reference)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetCandlesRequestView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetCandlesRequest";
            const FULL_NAME: &'static str = "marketdata.v1.GetCandlesRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesRequest";
        }
        ::buffa::impl_default_view_instance!(GetCandlesRequestView);
        ::buffa::impl_view_reborrow!(GetCandlesRequestView);
        /** Self-contained, `'static` owned view of a `GetCandlesRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetCandlesRequestView`]`<'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 [`GetCandlesRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetCandlesRequestOwnedView(
            ::buffa::OwnedView<GetCandlesRequestView<'static>>,
        );
        impl GetCandlesRequestOwnedView {
            /// 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(
                    GetCandlesRequestOwnedView(::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(
                    GetCandlesRequestOwnedView(
                        ::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::GetCandlesRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetCandlesRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetCandlesRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetCandlesRequestView<'_> {
                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::GetCandlesRequest,
                ::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
            }
            /// Candle bucket size. Required for ConnectRPC clients.
            ///
            /// Field 2: `timeframe`
            #[must_use]
            pub fn timeframe(&self) -> ::buffa::EnumValue<super::super::Timeframe> {
                self.0.reborrow().timeframe
            }
            /// Maximum number of closed candles to return. Defaults to 500 when unset;
            /// max 10000.
            ///
            /// Field 3: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
            /// Must not be more than 5 minutes in the future.
            ///
            /// Field 4: `start_time`
            #[must_use]
            pub fn start_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().start_time
            }
            /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
            /// Must be greater than or equal to start_time when both are set, and must not
            /// be more than 5 minutes in the future.
            ///
            /// Field 5: `end_time`
            #[must_use]
            pub fn end_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().end_time
            }
            /// Include the current open candle when it is available and inside the
            /// requested range.
            /// The open candle is prepended to the newest-first candle list and does not
            /// count toward the closed-candle limit.
            ///
            /// Field 6: `include_incomplete`
            #[must_use]
            pub fn include_incomplete(&self) -> bool {
                self.0.reborrow().include_incomplete
            }
            /// Include the composite reference market candle series for the same market,
            /// timeframe, and time range.
            /// The reference series can be empty when no reference series is available for
            /// the requested timeframe.
            ///
            /// Field 7: `include_reference`
            #[must_use]
            pub fn include_reference(&self) -> bool {
                self.0.reborrow().include_reference
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, timeframe, time bounds, and newest-first candle ordering.
            /// Inclusion flags affect response enrichment and may change between pages.
            ///
            /// Field 8: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetCandlesRequestView<'static>>>
        for GetCandlesRequestOwnedView {
            fn from(inner: ::buffa::OwnedView<GetCandlesRequestView<'static>>) -> Self {
                GetCandlesRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetCandlesRequestOwnedView>
        for ::buffa::OwnedView<GetCandlesRequestView<'static>> {
            fn from(wrapper: GetCandlesRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetCandlesRequestView<'static>>>
        for GetCandlesRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetCandlesRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetCandlesRequest {
            type View<'a> = GetCandlesRequestView<'a>;
            type ViewHandle = GetCandlesRequestOwnedView;
        }
        impl ::serde::Serialize for GetCandlesRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetCandlesColumnsRequest selects a spot market candle series for columnar output.
        ///
        /// The response is ordered oldest-first for efficient chart ingestion. When both
        /// start_time and end_time are set, both bounds are inclusive.
        #[derive(Clone, Debug, Default)]
        pub struct GetCandlesColumnsRequestView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Candle bucket size. Required for ConnectRPC clients.
            ///
            /// Field 2: `timeframe`
            pub timeframe: ::buffa::EnumValue<super::super::Timeframe>,
            /// Maximum number of closed candles to return. Defaults to 500 when unset;
            /// max 10000.
            ///
            /// Field 3: `limit`
            pub limit: u32,
            /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
            /// Must not be more than 5 minutes in the future.
            ///
            /// Field 4: `start_time`
            pub start_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
            /// Must be greater than or equal to start_time when both are set, and must not
            /// be more than 5 minutes in the future.
            ///
            /// Field 5: `end_time`
            pub end_time: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Include the current open candle when it is available and inside the
            /// requested range.
            /// The open candle is prepended to the newest-first candle list and does not
            /// count toward the closed-candle limit.
            ///
            /// Field 6: `include_incomplete`
            pub include_incomplete: bool,
            /// Include the composite reference market candle series for the same market,
            /// timeframe, and time range.
            /// The reference series can be empty when no reference series is available for
            /// the requested timeframe.
            ///
            /// Field 7: `include_reference`
            pub include_reference: bool,
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, timeframe, time bounds, and oldest-first candle ordering.
            /// Inclusion flags and columnar response shape may change between pages.
            ///
            /// Field 8: `page_token`
            pub page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetCandlesColumnsRequestView<'a> {
            type Owned = super::super::GetCandlesColumnsRequest;
            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::Varint,
                        )?;
                        view.timeframe = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.limit = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.start_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.start_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.end_time.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.end_time = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.include_incomplete = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.include_reference = ::buffa::types::decode_bool(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::GetCandlesColumnsRequest,
                ::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::GetCandlesColumnsRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetCandlesColumnsRequest {
                    symbol_id: self.symbol_id,
                    timeframe: self.timeframe,
                    limit: self.limit,
                    start_time: match self.start_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    end_time: match self.end_time.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    include_incomplete: self.include_incomplete,
                    include_reference: self.include_reference,
                    page_token: self.page_token.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetCandlesColumnsRequestView<'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;
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.limit != 0u32 {
                    size += 1u32 + ::buffa::types::uint32_encoded_len(self.limit) as u32;
                }
                if self.start_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.start_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.end_time.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.end_time.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.include_incomplete {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.include_reference {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if !self.page_token.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.page_token)
                                as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if self.limit != 0u32 {
                    ::buffa::types::put_uint32_field(3u32, self.limit, buf);
                }
                if self.start_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.start_time.write_to(__cache, buf);
                }
                if self.end_time.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.end_time.write_to(__cache, buf);
                }
                if self.include_incomplete {
                    ::buffa::types::put_bool_field(6u32, self.include_incomplete, buf);
                }
                if self.include_reference {
                    ::buffa::types::put_bool_field(7u32, self.include_reference, buf);
                }
                if !self.page_token.is_empty() {
                    ::buffa::types::put_string_field(8u32, &self.page_token, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for GetCandlesColumnsRequestView<'__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_default_enum_value(
                    &self.timeframe,
                ) {
                    __map.serialize_entry("timeframe", &self.timeframe)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.limit) {
                    __map
                        .serialize_entry(
                            "limit",
                            &::buffa::json_helpers::ProtoJson(&self.limit),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .start_time
                        .as_option()
                    {
                        __map.serialize_entry("startTime", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self.end_time.as_option()
                    {
                        __map.serialize_entry("endTime", __v)?;
                    }
                }
                if self.include_incomplete {
                    __map
                        .serialize_entry("includeIncomplete", &self.include_incomplete)?;
                }
                if self.include_reference {
                    __map.serialize_entry("includeReference", &self.include_reference)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.page_token) {
                    __map.serialize_entry("pageToken", self.page_token)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetCandlesColumnsRequestView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetCandlesColumnsRequest";
            const FULL_NAME: &'static str = "marketdata.v1.GetCandlesColumnsRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesColumnsRequest";
        }
        ::buffa::impl_default_view_instance!(GetCandlesColumnsRequestView);
        ::buffa::impl_view_reborrow!(GetCandlesColumnsRequestView);
        /** Self-contained, `'static` owned view of a `GetCandlesColumnsRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetCandlesColumnsRequestView`]`<'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 [`GetCandlesColumnsRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetCandlesColumnsRequestOwnedView(
            ::buffa::OwnedView<GetCandlesColumnsRequestView<'static>>,
        );
        impl GetCandlesColumnsRequestOwnedView {
            /// 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(
                    GetCandlesColumnsRequestOwnedView(::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(
                    GetCandlesColumnsRequestOwnedView(
                        ::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::GetCandlesColumnsRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetCandlesColumnsRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetCandlesColumnsRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetCandlesColumnsRequestView<'_> {
                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::GetCandlesColumnsRequest,
                ::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
            }
            /// Candle bucket size. Required for ConnectRPC clients.
            ///
            /// Field 2: `timeframe`
            #[must_use]
            pub fn timeframe(&self) -> ::buffa::EnumValue<super::super::Timeframe> {
                self.0.reborrow().timeframe
            }
            /// Maximum number of closed candles to return. Defaults to 500 when unset;
            /// max 10000.
            ///
            /// Field 3: `limit`
            #[must_use]
            pub fn limit(&self) -> u32 {
                self.0.reborrow().limit
            }
            /// Inclusive lower bound for candle bucket start time, as a UTC timestamp.
            /// Must not be more than 5 minutes in the future.
            ///
            /// Field 4: `start_time`
            #[must_use]
            pub fn start_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().start_time
            }
            /// Inclusive upper bound for candle bucket start time, as a UTC timestamp.
            /// Must be greater than or equal to start_time when both are set, and must not
            /// be more than 5 minutes in the future.
            ///
            /// Field 5: `end_time`
            #[must_use]
            pub fn end_time(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().end_time
            }
            /// Include the current open candle when it is available and inside the
            /// requested range.
            /// The open candle is prepended to the newest-first candle list and does not
            /// count toward the closed-candle limit.
            ///
            /// Field 6: `include_incomplete`
            #[must_use]
            pub fn include_incomplete(&self) -> bool {
                self.0.reborrow().include_incomplete
            }
            /// Include the composite reference market candle series for the same market,
            /// timeframe, and time range.
            /// The reference series can be empty when no reference series is available for
            /// the requested timeframe.
            ///
            /// Field 7: `include_reference`
            #[must_use]
            pub fn include_reference(&self) -> bool {
                self.0.reborrow().include_reference
            }
            /// Opaque keyset cursor from a previous response. The cursor is exclusive and
            /// bound to symbol, timeframe, time bounds, and oldest-first candle ordering.
            /// Inclusion flags and columnar response shape may change between pages.
            ///
            /// Field 8: `page_token`
            #[must_use]
            pub fn page_token(&self) -> &'_ str {
                self.0.reborrow().page_token
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetCandlesColumnsRequestView<'static>>,
        > for GetCandlesColumnsRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetCandlesColumnsRequestView<'static>>,
            ) -> Self {
                GetCandlesColumnsRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetCandlesColumnsRequestOwnedView>
        for ::buffa::OwnedView<GetCandlesColumnsRequestView<'static>> {
            fn from(wrapper: GetCandlesColumnsRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetCandlesColumnsRequestView<'static>>,
        > for GetCandlesColumnsRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetCandlesColumnsRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetCandlesColumnsRequest {
            type View<'a> = GetCandlesColumnsRequestView<'a>;
            type ViewHandle = GetCandlesColumnsRequestOwnedView;
        }
        impl ::serde::Serialize for GetCandlesColumnsRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// CandlePoint is one OHLCV bucket represented with scaled integers.
        ///
        /// REST responses render these values as decimal strings in tuple order:
        /// \[ts_sec, open, high, low, close, volume\].
        #[derive(Clone, Debug, Default)]
        pub struct CandlePointView<'a> {
            /// Candle bucket start timestamp, in seconds since epoch (UTC).
            ///
            /// Field 1: `ts_sec`
            pub ts_sec: u64,
            /// Opening price in quote units scaled by 1e6.
            ///
            /// Field 2: `open`
            pub open: i64,
            /// Highest traded price in quote units scaled by 1e6.
            ///
            /// Field 3: `high`
            pub high: i64,
            /// Lowest traded price in quote units scaled by 1e6.
            ///
            /// Field 4: `low`
            pub low: i64,
            /// Closing price in quote units scaled by 1e6.
            ///
            /// Field 5: `close`
            pub close: i64,
            /// Traded base-asset quantity scaled by the market's base asset quantity_scale
            /// from GetSpotConfig.
            ///
            /// Field 6: `volume`
            pub volume: i64,
            /// True only for WebSocket terminal updates of a closed bucket.
            /// Historical API rows and current open-candle rows set this to false.
            ///
            /// Field 7: `is_closed`
            pub is_closed: bool,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for CandlePointView<'a> {
            type Owned = super::super::CandlePoint;
            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.ts_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.open = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.high = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.low = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.close = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.volume = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.is_closed = ::buffa::types::decode_bool(&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::CandlePoint,
                ::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::CandlePoint,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::CandlePoint {
                    ts_sec: self.ts_sec,
                    open: self.open,
                    high: self.high,
                    low: self.low,
                    close: self.close,
                    volume: self.volume,
                    is_closed: self.is_closed,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for CandlePointView<'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.ts_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
                }
                if self.open != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.open) as u32;
                }
                if self.high != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.high) as u32;
                }
                if self.low != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.low) as u32;
                }
                if self.close != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.close) as u32;
                }
                if self.volume != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.volume) as u32;
                }
                if self.is_closed {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(1u32, self.ts_sec, buf);
                }
                if self.open != 0i64 {
                    ::buffa::types::put_int64_field(2u32, self.open, buf);
                }
                if self.high != 0i64 {
                    ::buffa::types::put_int64_field(3u32, self.high, buf);
                }
                if self.low != 0i64 {
                    ::buffa::types::put_int64_field(4u32, self.low, buf);
                }
                if self.close != 0i64 {
                    ::buffa::types::put_int64_field(5u32, self.close, buf);
                }
                if self.volume != 0i64 {
                    ::buffa::types::put_int64_field(6u32, self.volume, buf);
                }
                if self.is_closed {
                    ::buffa::types::put_bool_field(7u32, self.is_closed, 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 CandlePointView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.open) {
                    __map
                        .serialize_entry(
                            "open",
                            &::buffa::json_helpers::ProtoJson(&self.open),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.high) {
                    __map
                        .serialize_entry(
                            "high",
                            &::buffa::json_helpers::ProtoJson(&self.high),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.low) {
                    __map
                        .serialize_entry(
                            "low",
                            &::buffa::json_helpers::ProtoJson(&self.low),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.close) {
                    __map
                        .serialize_entry(
                            "close",
                            &::buffa::json_helpers::ProtoJson(&self.close),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.volume) {
                    __map
                        .serialize_entry(
                            "volume",
                            &::buffa::json_helpers::ProtoJson(&self.volume),
                        )?;
                }
                if self.is_closed {
                    __map.serialize_entry("isClosed", &self.is_closed)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for CandlePointView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "CandlePoint";
            const FULL_NAME: &'static str = "marketdata.v1.CandlePoint";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.CandlePoint";
        }
        ::buffa::impl_default_view_instance!(CandlePointView);
        ::buffa::impl_view_reborrow!(CandlePointView);
        /** Self-contained, `'static` owned view of a `CandlePoint` message.

 Wraps [`::buffa::OwnedView`]`<`[`CandlePointView`]`<'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 [`CandlePointView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct CandlePointOwnedView(::buffa::OwnedView<CandlePointView<'static>>);
        impl CandlePointOwnedView {
            /// 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(
                    CandlePointOwnedView(::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(
                    CandlePointOwnedView(
                        ::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::CandlePoint,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CandlePointOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`CandlePointView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &CandlePointView<'_> {
                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::CandlePoint,
                ::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()
            }
            /// Candle bucket start timestamp, in seconds since epoch (UTC).
            ///
            /// Field 1: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
            /// Opening price in quote units scaled by 1e6.
            ///
            /// Field 2: `open`
            #[must_use]
            pub fn open(&self) -> i64 {
                self.0.reborrow().open
            }
            /// Highest traded price in quote units scaled by 1e6.
            ///
            /// Field 3: `high`
            #[must_use]
            pub fn high(&self) -> i64 {
                self.0.reborrow().high
            }
            /// Lowest traded price in quote units scaled by 1e6.
            ///
            /// Field 4: `low`
            #[must_use]
            pub fn low(&self) -> i64 {
                self.0.reborrow().low
            }
            /// Closing price in quote units scaled by 1e6.
            ///
            /// Field 5: `close`
            #[must_use]
            pub fn close(&self) -> i64 {
                self.0.reborrow().close
            }
            /// Traded base-asset quantity scaled by the market's base asset quantity_scale
            /// from GetSpotConfig.
            ///
            /// Field 6: `volume`
            #[must_use]
            pub fn volume(&self) -> i64 {
                self.0.reborrow().volume
            }
            /// True only for WebSocket terminal updates of a closed bucket.
            /// Historical API rows and current open-candle rows set this to false.
            ///
            /// Field 7: `is_closed`
            #[must_use]
            pub fn is_closed(&self) -> bool {
                self.0.reborrow().is_closed
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<CandlePointView<'static>>>
        for CandlePointOwnedView {
            fn from(inner: ::buffa::OwnedView<CandlePointView<'static>>) -> Self {
                CandlePointOwnedView(inner)
            }
        }
        impl ::core::convert::From<CandlePointOwnedView>
        for ::buffa::OwnedView<CandlePointView<'static>> {
            fn from(wrapper: CandlePointOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<CandlePointView<'static>>>
        for CandlePointOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<CandlePointView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::CandlePoint {
            type View<'a> = CandlePointView<'a>;
            type ViewHandle = CandlePointOwnedView;
        }
        impl ::serde::Serialize for CandlePointOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetCandlesResponse contains OHLCV candles for one spot market and timeframe.
        ///
        /// Candles and reference_candles are ordered newest-first by ts_sec. REST
        /// responses render price and volume values as decimal strings.
        #[derive(Clone, Debug, Default)]
        pub struct GetCandlesResponseView<'a> {
            /// Numeric spot market identifier echoed from the request.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Candle bucket size used for the returned series.
            ///
            /// Field 2: `timeframe`
            pub timeframe: ::buffa::EnumValue<super::super::Timeframe>,
            /// Primary market candle series, ordered newest-first by ts_sec.
            ///
            /// Field 3: `candles`
            pub candles: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::CandlePointView<'a>,
            >,
            /// Composite reference market candle series, ordered newest-first by ts_sec.
            /// Populated only when include_reference is true and reference data is
            /// available.
            ///
            /// Field 4: `reference_candles`
            pub reference_candles: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::CandlePointView<'a>,
            >,
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 5: `next_page_token`
            pub next_page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetCandlesResponseView<'a> {
            type Owned = super::super::GetCandlesResponse;
            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::Varint,
                        )?;
                        view.timeframe = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.next_page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.candles
                            .push(
                                <super::super::__buffa::view::CandlePointView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.reference_candles
                            .push(
                                <super::super::__buffa::view::CandlePointView 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::GetCandlesResponse,
                ::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::GetCandlesResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetCandlesResponse {
                    symbol_id: self.symbol_id,
                    timeframe: self.timeframe,
                    candles: self
                        .candles
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    reference_candles: self
                        .reference_candles
                        .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 GetCandlesResponseView<'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;
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                for v in &self.candles {
                    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;
                }
                for v in &self.reference_candles {
                    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 _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                for v in &self.candles {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                for v in &self.reference_candles {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if !self.next_page_token.is_empty() {
                    ::buffa::types::put_string_field(5u32, &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 GetCandlesResponseView<'__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_default_enum_value(
                    &self.timeframe,
                ) {
                    __map.serialize_entry("timeframe", &self.timeframe)?;
                }
                if !self.candles.is_empty() {
                    __map.serialize_entry("candles", &*self.candles)?;
                }
                if !self.reference_candles.is_empty() {
                    __map.serialize_entry("referenceCandles", &*self.reference_candles)?;
                }
                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 GetCandlesResponseView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetCandlesResponse";
            const FULL_NAME: &'static str = "marketdata.v1.GetCandlesResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesResponse";
        }
        ::buffa::impl_default_view_instance!(GetCandlesResponseView);
        ::buffa::impl_view_reborrow!(GetCandlesResponseView);
        /** Self-contained, `'static` owned view of a `GetCandlesResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetCandlesResponseView`]`<'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 [`GetCandlesResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetCandlesResponseOwnedView(
            ::buffa::OwnedView<GetCandlesResponseView<'static>>,
        );
        impl GetCandlesResponseOwnedView {
            /// 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(
                    GetCandlesResponseOwnedView(::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(
                    GetCandlesResponseOwnedView(
                        ::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::GetCandlesResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetCandlesResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetCandlesResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetCandlesResponseView<'_> {
                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::GetCandlesResponse,
                ::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 echoed from the request.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Candle bucket size used for the returned series.
            ///
            /// Field 2: `timeframe`
            #[must_use]
            pub fn timeframe(&self) -> ::buffa::EnumValue<super::super::Timeframe> {
                self.0.reborrow().timeframe
            }
            /// Primary market candle series, ordered newest-first by ts_sec.
            ///
            /// Field 3: `candles`
            #[must_use]
            pub fn candles(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::CandlePointView<'_>,
            > {
                &self.0.reborrow().candles
            }
            /// Composite reference market candle series, ordered newest-first by ts_sec.
            /// Populated only when include_reference is true and reference data is
            /// available.
            ///
            /// Field 4: `reference_candles`
            #[must_use]
            pub fn reference_candles(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::CandlePointView<'_>,
            > {
                &self.0.reborrow().reference_candles
            }
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 5: `next_page_token`
            #[must_use]
            pub fn next_page_token(&self) -> &'_ str {
                self.0.reborrow().next_page_token
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetCandlesResponseView<'static>>>
        for GetCandlesResponseOwnedView {
            fn from(inner: ::buffa::OwnedView<GetCandlesResponseView<'static>>) -> Self {
                GetCandlesResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetCandlesResponseOwnedView>
        for ::buffa::OwnedView<GetCandlesResponseView<'static>> {
            fn from(wrapper: GetCandlesResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<GetCandlesResponseView<'static>>>
        for GetCandlesResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetCandlesResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetCandlesResponse {
            type View<'a> = GetCandlesResponseView<'a>;
            type ViewHandle = GetCandlesResponseOwnedView;
        }
        impl ::serde::Serialize for GetCandlesResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetCandlesColumnsResponse returns the same candle series as GetCandles but in columnar form.
        /// This is optimized for charting clients that ingest arrays of each field (binary only).
        ///
        /// Ordering: values are returned oldest-first (ascending ts_sec).
        #[derive(Clone, Debug, Default)]
        pub struct GetCandlesColumnsResponseView<'a> {
            /// Numeric spot market identifier.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Timeframe of this series.
            ///
            /// Field 2: `timeframe`
            pub timeframe: ::buffa::EnumValue<super::super::Timeframe>,
            /// Candle bucket start timestamps (seconds since epoch, UTC).
            ///
            /// Field 3: `ts_sec`
            pub ts_sec: ::buffa::RepeatedView<'a, u64>,
            /// Opening prices in quote units scaled by 1e6.
            ///
            /// Field 4: `open`
            pub open: ::buffa::RepeatedView<'a, i64>,
            /// Highest traded prices in quote units scaled by 1e6.
            ///
            /// Field 5: `high`
            pub high: ::buffa::RepeatedView<'a, i64>,
            /// Lowest traded prices in quote units scaled by 1e6.
            ///
            /// Field 6: `low`
            pub low: ::buffa::RepeatedView<'a, i64>,
            /// Closing prices in quote units scaled by 1e6.
            ///
            /// Field 7: `close`
            pub close: ::buffa::RepeatedView<'a, i64>,
            /// Traded base-asset quantities scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume`
            pub volume: ::buffa::RepeatedView<'a, i64>,
            /// Reference candle series in columnar form (same ordering as ts_sec: oldest-first).
            /// Only populated when request.include_reference=true.
            ///
            /// Field 9: `reference_ts_sec`
            pub reference_ts_sec: ::buffa::RepeatedView<'a, u64>,
            /// Reference opening prices in quote units scaled by 1e6.
            ///
            /// Field 10: `reference_open`
            pub reference_open: ::buffa::RepeatedView<'a, i64>,
            /// Reference high prices in quote units scaled by 1e6.
            ///
            /// Field 11: `reference_high`
            pub reference_high: ::buffa::RepeatedView<'a, i64>,
            /// Reference low prices in quote units scaled by 1e6.
            ///
            /// Field 12: `reference_low`
            pub reference_low: ::buffa::RepeatedView<'a, i64>,
            /// Reference closing prices in quote units scaled by 1e6.
            ///
            /// Field 13: `reference_close`
            pub reference_close: ::buffa::RepeatedView<'a, i64>,
            /// Reference traded base-asset quantities scaled by the pair's
            /// base_quantity_scale from GetSpotConfig.
            ///
            /// Field 14: `reference_volume`
            pub reference_volume: ::buffa::RepeatedView<'a, i64>,
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 15: `next_page_token`
            pub next_page_token: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetCandlesColumnsResponseView<'a> {
            type Owned = super::super::GetCandlesColumnsResponse;
            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::Varint,
                        )?;
                        view.timeframe = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    15u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.next_page_token = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    3u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.ts_sec
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.ts_sec.push(::buffa::types::decode_uint64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.ts_sec.push(::buffa::types::decode_uint64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    4u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.open.reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.open.push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.open.push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    5u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.high.reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.high.push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.high.push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    6u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.low.reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.low.push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.low.push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    7u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.close
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.close.push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.close.push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    8u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.volume
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.volume.push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.volume.push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    9u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_ts_sec
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_ts_sec
                                    .push(::buffa::types::decode_uint64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_ts_sec
                                .push(::buffa::types::decode_uint64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    10u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_open
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_open
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_open
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    11u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_high
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_high
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_high
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    12u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_low
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_low
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_low
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    13u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_close
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_close
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_close
                                .push(::buffa::types::decode_int64(&mut cur)?);
                        } else {
                            return Err(
                                ::buffa::encoding::wire_type_mismatch(
                                    tag,
                                    ::buffa::encoding::WireType::LengthDelimited,
                                ),
                            );
                        }
                    }
                    14u32 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.reference_volume
                                .reserve(::buffa::encoding::count_varints(payload));
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.reference_volume
                                    .push(::buffa::types::decode_int64(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Varint
                        {
                            view.reference_volume
                                .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::GetCandlesColumnsResponse,
                ::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::GetCandlesColumnsResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetCandlesColumnsResponse {
                    symbol_id: self.symbol_id,
                    timeframe: self.timeframe,
                    ts_sec: self.ts_sec.to_vec(),
                    open: self.open.to_vec(),
                    high: self.high.to_vec(),
                    low: self.low.to_vec(),
                    close: self.close.to_vec(),
                    volume: self.volume.to_vec(),
                    reference_ts_sec: self.reference_ts_sec.to_vec(),
                    reference_open: self.reference_open.to_vec(),
                    reference_high: self.reference_high.to_vec(),
                    reference_low: self.reference_low.to_vec(),
                    reference_close: self.reference_close.to_vec(),
                    reference_volume: self.reference_volume.to_vec(),
                    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 GetCandlesColumnsResponseView<'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;
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if !self.ts_sec.is_empty() {
                    let payload: u32 = self
                        .ts_sec
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                if !self.open.is_empty() {
                    let payload: u32 = self
                        .open
                        .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;
                }
                if !self.high.is_empty() {
                    let payload: u32 = self
                        .high
                        .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;
                }
                if !self.low.is_empty() {
                    let payload: u32 = self
                        .low
                        .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;
                }
                if !self.close.is_empty() {
                    let payload: u32 = self
                        .close
                        .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;
                }
                if !self.volume.is_empty() {
                    let payload: u32 = self
                        .volume
                        .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;
                }
                if !self.reference_ts_sec.is_empty() {
                    let payload: u32 = self
                        .reference_ts_sec
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                if !self.reference_open.is_empty() {
                    let payload: u32 = self
                        .reference_open
                        .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;
                }
                if !self.reference_high.is_empty() {
                    let payload: u32 = self
                        .reference_high
                        .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;
                }
                if !self.reference_low.is_empty() {
                    let payload: u32 = self
                        .reference_low
                        .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;
                }
                if !self.reference_close.is_empty() {
                    let payload: u32 = self
                        .reference_close
                        .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;
                }
                if !self.reference_volume.is_empty() {
                    let payload: u32 = self
                        .reference_volume
                        .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;
                }
                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 _;
                if self.symbol_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.symbol_id, buf);
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if !self.ts_sec.is_empty() {
                    let payload: u32 = self
                        .ts_sec
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(3u32, payload, buf);
                    for &v in &self.ts_sec {
                        ::buffa::types::encode_uint64(v, buf);
                    }
                }
                if !self.open.is_empty() {
                    let payload: u32 = self
                        .open
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(4u32, payload, buf);
                    for &v in &self.open {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.high.is_empty() {
                    let payload: u32 = self
                        .high
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(5u32, payload, buf);
                    for &v in &self.high {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.low.is_empty() {
                    let payload: u32 = self
                        .low
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(6u32, payload, buf);
                    for &v in &self.low {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.close.is_empty() {
                    let payload: u32 = self
                        .close
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(7u32, payload, buf);
                    for &v in &self.close {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.volume.is_empty() {
                    let payload: u32 = self
                        .volume
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(8u32, payload, buf);
                    for &v in &self.volume {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.reference_ts_sec.is_empty() {
                    let payload: u32 = self
                        .reference_ts_sec
                        .iter()
                        .map(|&v| ::buffa::types::uint64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(9u32, payload, buf);
                    for &v in &self.reference_ts_sec {
                        ::buffa::types::encode_uint64(v, buf);
                    }
                }
                if !self.reference_open.is_empty() {
                    let payload: u32 = self
                        .reference_open
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(10u32, payload, buf);
                    for &v in &self.reference_open {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.reference_high.is_empty() {
                    let payload: u32 = self
                        .reference_high
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(11u32, payload, buf);
                    for &v in &self.reference_high {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.reference_low.is_empty() {
                    let payload: u32 = self
                        .reference_low
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(12u32, payload, buf);
                    for &v in &self.reference_low {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.reference_close.is_empty() {
                    let payload: u32 = self
                        .reference_close
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(13u32, payload, buf);
                    for &v in &self.reference_close {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.reference_volume.is_empty() {
                    let payload: u32 = self
                        .reference_volume
                        .iter()
                        .map(|&v| ::buffa::types::int64_encoded_len(v) as u32)
                        .sum::<u32>();
                    ::buffa::types::put_len_delimited_header(14u32, payload, buf);
                    for &v in &self.reference_volume {
                        ::buffa::types::encode_int64(v, buf);
                    }
                }
                if !self.next_page_token.is_empty() {
                    ::buffa::types::put_string_field(15u32, &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 GetCandlesColumnsResponseView<'__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_default_enum_value(
                    &self.timeframe,
                ) {
                    __map.serialize_entry("timeframe", &self.timeframe)?;
                }
                if !self.ts_sec.is_empty() {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::RepeatedJson(&self.ts_sec),
                        )?;
                }
                if !self.open.is_empty() {
                    __map
                        .serialize_entry(
                            "open",
                            &::buffa::json_helpers::RepeatedJson(&self.open),
                        )?;
                }
                if !self.high.is_empty() {
                    __map
                        .serialize_entry(
                            "high",
                            &::buffa::json_helpers::RepeatedJson(&self.high),
                        )?;
                }
                if !self.low.is_empty() {
                    __map
                        .serialize_entry(
                            "low",
                            &::buffa::json_helpers::RepeatedJson(&self.low),
                        )?;
                }
                if !self.close.is_empty() {
                    __map
                        .serialize_entry(
                            "close",
                            &::buffa::json_helpers::RepeatedJson(&self.close),
                        )?;
                }
                if !self.volume.is_empty() {
                    __map
                        .serialize_entry(
                            "volume",
                            &::buffa::json_helpers::RepeatedJson(&self.volume),
                        )?;
                }
                if !self.reference_ts_sec.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceTsSec",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_ts_sec),
                        )?;
                }
                if !self.reference_open.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceOpen",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_open),
                        )?;
                }
                if !self.reference_high.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceHigh",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_high),
                        )?;
                }
                if !self.reference_low.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceLow",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_low),
                        )?;
                }
                if !self.reference_close.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceClose",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_close),
                        )?;
                }
                if !self.reference_volume.is_empty() {
                    __map
                        .serialize_entry(
                            "referenceVolume",
                            &::buffa::json_helpers::RepeatedJson(&self.reference_volume),
                        )?;
                }
                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 GetCandlesColumnsResponseView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetCandlesColumnsResponse";
            const FULL_NAME: &'static str = "marketdata.v1.GetCandlesColumnsResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetCandlesColumnsResponse";
        }
        ::buffa::impl_default_view_instance!(GetCandlesColumnsResponseView);
        ::buffa::impl_view_reborrow!(GetCandlesColumnsResponseView);
        /** Self-contained, `'static` owned view of a `GetCandlesColumnsResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetCandlesColumnsResponseView`]`<'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 [`GetCandlesColumnsResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetCandlesColumnsResponseOwnedView(
            ::buffa::OwnedView<GetCandlesColumnsResponseView<'static>>,
        );
        impl GetCandlesColumnsResponseOwnedView {
            /// 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(
                    GetCandlesColumnsResponseOwnedView(
                        ::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(
                    GetCandlesColumnsResponseOwnedView(
                        ::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::GetCandlesColumnsResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetCandlesColumnsResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`GetCandlesColumnsResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetCandlesColumnsResponseView<'_> {
                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::GetCandlesColumnsResponse,
                ::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
            }
            /// Timeframe of this series.
            ///
            /// Field 2: `timeframe`
            #[must_use]
            pub fn timeframe(&self) -> ::buffa::EnumValue<super::super::Timeframe> {
                self.0.reborrow().timeframe
            }
            /// Candle bucket start timestamps (seconds since epoch, UTC).
            ///
            /// Field 3: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> &::buffa::RepeatedView<'_, u64> {
                &self.0.reborrow().ts_sec
            }
            /// Opening prices in quote units scaled by 1e6.
            ///
            /// Field 4: `open`
            #[must_use]
            pub fn open(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().open
            }
            /// Highest traded prices in quote units scaled by 1e6.
            ///
            /// Field 5: `high`
            #[must_use]
            pub fn high(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().high
            }
            /// Lowest traded prices in quote units scaled by 1e6.
            ///
            /// Field 6: `low`
            #[must_use]
            pub fn low(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().low
            }
            /// Closing prices in quote units scaled by 1e6.
            ///
            /// Field 7: `close`
            #[must_use]
            pub fn close(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().close
            }
            /// Traded base-asset quantities scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume`
            #[must_use]
            pub fn volume(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().volume
            }
            /// Reference candle series in columnar form (same ordering as ts_sec: oldest-first).
            /// Only populated when request.include_reference=true.
            ///
            /// Field 9: `reference_ts_sec`
            #[must_use]
            pub fn reference_ts_sec(&self) -> &::buffa::RepeatedView<'_, u64> {
                &self.0.reborrow().reference_ts_sec
            }
            /// Reference opening prices in quote units scaled by 1e6.
            ///
            /// Field 10: `reference_open`
            #[must_use]
            pub fn reference_open(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().reference_open
            }
            /// Reference high prices in quote units scaled by 1e6.
            ///
            /// Field 11: `reference_high`
            #[must_use]
            pub fn reference_high(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().reference_high
            }
            /// Reference low prices in quote units scaled by 1e6.
            ///
            /// Field 12: `reference_low`
            #[must_use]
            pub fn reference_low(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().reference_low
            }
            /// Reference closing prices in quote units scaled by 1e6.
            ///
            /// Field 13: `reference_close`
            #[must_use]
            pub fn reference_close(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().reference_close
            }
            /// Reference traded base-asset quantities scaled by the pair's
            /// base_quantity_scale from GetSpotConfig.
            ///
            /// Field 14: `reference_volume`
            #[must_use]
            pub fn reference_volume(&self) -> &::buffa::RepeatedView<'_, i64> {
                &self.0.reborrow().reference_volume
            }
            /// Opaque cursor for the next page. Empty when no more results exist.
            ///
            /// Field 15: `next_page_token`
            #[must_use]
            pub fn next_page_token(&self) -> &'_ str {
                self.0.reborrow().next_page_token
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetCandlesColumnsResponseView<'static>>,
        > for GetCandlesColumnsResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetCandlesColumnsResponseView<'static>>,
            ) -> Self {
                GetCandlesColumnsResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetCandlesColumnsResponseOwnedView>
        for ::buffa::OwnedView<GetCandlesColumnsResponseView<'static>> {
            fn from(wrapper: GetCandlesColumnsResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetCandlesColumnsResponseView<'static>>,
        > for GetCandlesColumnsResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<GetCandlesColumnsResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetCandlesColumnsResponse {
            type View<'a> = GetCandlesColumnsResponseView<'a>;
            type ViewHandle = GetCandlesColumnsResponseOwnedView;
        }
        impl ::serde::Serialize for GetCandlesColumnsResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ---------------------------------------------------------------------------
        /// Candle contains one public OHLCV bucket.
        /// ---------------------------------------------------------------------------
        ///
        /// Candle represents a single OHLCV bucket for a symbol and timeframe.
        #[derive(Clone, Debug, Default)]
        pub struct CandleView<'a> {
            /// numeric spot market identifier
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// timeframe of this candle
            ///
            /// Field 2: `timeframe`
            pub timeframe: ::buffa::EnumValue<super::super::Timeframe>,
            /// bucket start timestamp (seconds since epoch, UTC)
            ///
            /// Field 3: `ts_sec`
            pub ts_sec: u64,
            /// opening price in quote units scaled by 1e6
            ///
            /// Field 4: `open`
            pub open: i64,
            /// highest traded price in quote units scaled by 1e6
            ///
            /// Field 5: `high`
            pub high: i64,
            /// lowest traded price in quote units scaled by 1e6
            ///
            /// Field 6: `low`
            pub low: i64,
            /// closing price in quote units scaled by 1e6
            ///
            /// Field 7: `close`
            pub close: i64,
            /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume`
            pub volume: i64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for CandleView<'a> {
            type Owned = super::super::Candle;
            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::Varint,
                        )?;
                        view.timeframe = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_sec = ::buffa::types::decode_uint64(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.open = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.high = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.low = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.close = ::buffa::types::decode_int64(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.volume = ::buffa::types::decode_int64(&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::Candle, ::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::Candle, ::buffa::DecodeError> {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::Candle {
                    symbol_id: self.symbol_id,
                    timeframe: self.timeframe,
                    ts_sec: self.ts_sec,
                    open: self.open,
                    high: self.high,
                    low: self.low,
                    close: self.close,
                    volume: self.volume,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for CandleView<'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;
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.ts_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) as u32;
                }
                if self.open != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.open) as u32;
                }
                if self.high != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.high) as u32;
                }
                if self.low != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.low) as u32;
                }
                if self.close != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.close) as u32;
                }
                if self.volume != 0i64 {
                    size += 1u32 + ::buffa::types::int64_encoded_len(self.volume) 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);
                }
                {
                    let val = self.timeframe.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(2u32, val, buf);
                    }
                }
                if self.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(3u32, self.ts_sec, buf);
                }
                if self.open != 0i64 {
                    ::buffa::types::put_int64_field(4u32, self.open, buf);
                }
                if self.high != 0i64 {
                    ::buffa::types::put_int64_field(5u32, self.high, buf);
                }
                if self.low != 0i64 {
                    ::buffa::types::put_int64_field(6u32, self.low, buf);
                }
                if self.close != 0i64 {
                    ::buffa::types::put_int64_field(7u32, self.close, buf);
                }
                if self.volume != 0i64 {
                    ::buffa::types::put_int64_field(8u32, self.volume, 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 CandleView<'__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_default_enum_value(
                    &self.timeframe,
                ) {
                    __map.serialize_entry("timeframe", &self.timeframe)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.open) {
                    __map
                        .serialize_entry(
                            "open",
                            &::buffa::json_helpers::ProtoJson(&self.open),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.high) {
                    __map
                        .serialize_entry(
                            "high",
                            &::buffa::json_helpers::ProtoJson(&self.high),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.low) {
                    __map
                        .serialize_entry(
                            "low",
                            &::buffa::json_helpers::ProtoJson(&self.low),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.close) {
                    __map
                        .serialize_entry(
                            "close",
                            &::buffa::json_helpers::ProtoJson(&self.close),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i64(&self.volume) {
                    __map
                        .serialize_entry(
                            "volume",
                            &::buffa::json_helpers::ProtoJson(&self.volume),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for CandleView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "Candle";
            const FULL_NAME: &'static str = "marketdata.v1.Candle";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.Candle";
        }
        ::buffa::impl_default_view_instance!(CandleView);
        ::buffa::impl_view_reborrow!(CandleView);
        /** Self-contained, `'static` owned view of a `Candle` message.

 Wraps [`::buffa::OwnedView`]`<`[`CandleView`]`<'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 [`CandleView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct CandleOwnedView(::buffa::OwnedView<CandleView<'static>>);
        impl CandleOwnedView {
            /// 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(
                    CandleOwnedView(::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(
                    CandleOwnedView(
                        ::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::Candle,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CandleOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`CandleView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &CandleView<'_> {
                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::Candle, ::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
            }
            /// timeframe of this candle
            ///
            /// Field 2: `timeframe`
            #[must_use]
            pub fn timeframe(&self) -> ::buffa::EnumValue<super::super::Timeframe> {
                self.0.reborrow().timeframe
            }
            /// bucket start timestamp (seconds since epoch, UTC)
            ///
            /// Field 3: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
            /// opening price in quote units scaled by 1e6
            ///
            /// Field 4: `open`
            #[must_use]
            pub fn open(&self) -> i64 {
                self.0.reborrow().open
            }
            /// highest traded price in quote units scaled by 1e6
            ///
            /// Field 5: `high`
            #[must_use]
            pub fn high(&self) -> i64 {
                self.0.reborrow().high
            }
            /// lowest traded price in quote units scaled by 1e6
            ///
            /// Field 6: `low`
            #[must_use]
            pub fn low(&self) -> i64 {
                self.0.reborrow().low
            }
            /// closing price in quote units scaled by 1e6
            ///
            /// Field 7: `close`
            #[must_use]
            pub fn close(&self) -> i64 {
                self.0.reborrow().close
            }
            /// Traded base-asset quantity scaled by the pair's base_quantity_scale from
            /// GetSpotConfig.
            ///
            /// Field 8: `volume`
            #[must_use]
            pub fn volume(&self) -> i64 {
                self.0.reborrow().volume
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<CandleView<'static>>>
        for CandleOwnedView {
            fn from(inner: ::buffa::OwnedView<CandleView<'static>>) -> Self {
                CandleOwnedView(inner)
            }
        }
        impl ::core::convert::From<CandleOwnedView>
        for ::buffa::OwnedView<CandleView<'static>> {
            fn from(wrapper: CandleOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<CandleView<'static>>>
        for CandleOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<CandleView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::Candle {
            type View<'a> = CandleView<'a>;
            type ViewHandle = CandleOwnedView;
        }
        impl ::serde::Serialize for CandleOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ---------------------------------------------------------------------------
        /// GetSpotConfig: spot assets and pair reference data.
        /// ---------------------------------------------------------------------------
        ///
        /// AssetConfig describes one spot asset returned by GetSpotConfig.
        #[derive(Clone, Debug, Default)]
        pub struct AssetConfigView<'a> {
            /// Asset code, e.g. "USDT" or "BTC".
            ///
            /// Field 1: `asset`
            pub asset: &'a str,
            /// Stable numeric asset id used by account, balance, and order APIs.
            ///
            /// Field 2: `ledger_id`
            pub ledger_id: u32,
            /// Human-friendly display name, e.g. "Bitcoin".
            ///
            /// Field 3: `name`
            pub name: &'a str,
            /// Suggested decimal precision for displaying user-facing asset amounts.
            ///
            /// Field 4: `quantity_display_decimals`
            pub quantity_display_decimals: u32,
            /// Integer scale for quantities and balances in this asset (0..18).
            /// A scale of 8 means one whole asset is represented as 100000000 in scaled
            /// integer fields such as qty_scaled.
            ///
            /// Field 5: `quantity_scale`
            pub quantity_scale: u32,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for AssetConfigView<'a> {
            type Owned = super::super::AssetConfig;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.asset = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ledger_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.name = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quantity_display_decimals = ::buffa::types::decode_uint32(
                            &mut cur,
                        )?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quantity_scale = ::buffa::types::decode_uint32(&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::AssetConfig,
                ::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::AssetConfig,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::AssetConfig {
                    asset: self.asset.to_string(),
                    ledger_id: self.ledger_id,
                    name: self.name.to_string(),
                    quantity_display_decimals: self.quantity_display_decimals,
                    quantity_scale: self.quantity_scale,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for AssetConfigView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                if !self.asset.is_empty() {
                    size
                        += 1u32 + ::buffa::types::string_encoded_len(&self.asset) as u32;
                }
                if self.ledger_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.ledger_id) as u32;
                }
                if !self.name.is_empty() {
                    size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
                }
                if self.quantity_display_decimals != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(
                                self.quantity_display_decimals,
                            ) as u32;
                }
                if self.quantity_scale != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.quantity_scale)
                                as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if !self.asset.is_empty() {
                    ::buffa::types::put_string_field(1u32, &self.asset, buf);
                }
                if self.ledger_id != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.ledger_id, buf);
                }
                if !self.name.is_empty() {
                    ::buffa::types::put_string_field(3u32, &self.name, buf);
                }
                if self.quantity_display_decimals != 0u32 {
                    ::buffa::types::put_uint32_field(
                        4u32,
                        self.quantity_display_decimals,
                        buf,
                    );
                }
                if self.quantity_scale != 0u32 {
                    ::buffa::types::put_uint32_field(5u32, self.quantity_scale, 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 AssetConfigView<'__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_empty_str(self.asset) {
                    __map.serialize_entry("asset", self.asset)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.ledger_id) {
                    __map
                        .serialize_entry(
                            "ledgerId",
                            &::buffa::json_helpers::ProtoJson(&self.ledger_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
                    __map.serialize_entry("name", self.name)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(
                    &self.quantity_display_decimals,
                ) {
                    __map
                        .serialize_entry(
                            "quantityDisplayDecimals",
                            &::buffa::json_helpers::ProtoJson(
                                &self.quantity_display_decimals,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.quantity_scale) {
                    __map
                        .serialize_entry(
                            "quantityScale",
                            &::buffa::json_helpers::ProtoJson(&self.quantity_scale),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for AssetConfigView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "AssetConfig";
            const FULL_NAME: &'static str = "marketdata.v1.AssetConfig";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.AssetConfig";
        }
        ::buffa::impl_default_view_instance!(AssetConfigView);
        ::buffa::impl_view_reborrow!(AssetConfigView);
        /** Self-contained, `'static` owned view of a `AssetConfig` message.

 Wraps [`::buffa::OwnedView`]`<`[`AssetConfigView`]`<'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 [`AssetConfigView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct AssetConfigOwnedView(::buffa::OwnedView<AssetConfigView<'static>>);
        impl AssetConfigOwnedView {
            /// 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(
                    AssetConfigOwnedView(::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(
                    AssetConfigOwnedView(
                        ::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::AssetConfig,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    AssetConfigOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`AssetConfigView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &AssetConfigView<'_> {
                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::AssetConfig,
                ::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()
            }
            /// Asset code, e.g. "USDT" or "BTC".
            ///
            /// Field 1: `asset`
            #[must_use]
            pub fn asset(&self) -> &'_ str {
                self.0.reborrow().asset
            }
            /// Stable numeric asset id used by account, balance, and order APIs.
            ///
            /// Field 2: `ledger_id`
            #[must_use]
            pub fn ledger_id(&self) -> u32 {
                self.0.reborrow().ledger_id
            }
            /// Human-friendly display name, e.g. "Bitcoin".
            ///
            /// Field 3: `name`
            #[must_use]
            pub fn name(&self) -> &'_ str {
                self.0.reborrow().name
            }
            /// Suggested decimal precision for displaying user-facing asset amounts.
            ///
            /// Field 4: `quantity_display_decimals`
            #[must_use]
            pub fn quantity_display_decimals(&self) -> u32 {
                self.0.reborrow().quantity_display_decimals
            }
            /// Integer scale for quantities and balances in this asset (0..18).
            /// A scale of 8 means one whole asset is represented as 100000000 in scaled
            /// integer fields such as qty_scaled.
            ///
            /// Field 5: `quantity_scale`
            #[must_use]
            pub fn quantity_scale(&self) -> u32 {
                self.0.reborrow().quantity_scale
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<AssetConfigView<'static>>>
        for AssetConfigOwnedView {
            fn from(inner: ::buffa::OwnedView<AssetConfigView<'static>>) -> Self {
                AssetConfigOwnedView(inner)
            }
        }
        impl ::core::convert::From<AssetConfigOwnedView>
        for ::buffa::OwnedView<AssetConfigView<'static>> {
            fn from(wrapper: AssetConfigOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<AssetConfigView<'static>>>
        for AssetConfigOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<AssetConfigView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::AssetConfig {
            type View<'a> = AssetConfigView<'a>;
            type ViewHandle = AssetConfigOwnedView;
        }
        impl ::serde::Serialize for AssetConfigOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// PairMarketdataConfig describes market-data display settings for a spot pair.
        #[derive(Clone, Debug, Default)]
        pub struct PairMarketdataConfigView<'a> {
            /// Suggested order book aggregation bucket sizes in quote-asset price units,
            /// e.g. 0.01, 0.1, 1, or 10.
            ///
            /// Field 1: `orderbook_price_buckets`
            pub orderbook_price_buckets: ::buffa::RepeatedView<'a, f64>,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for PairMarketdataConfigView<'a> {
            type Owned = super::super::PairMarketdataConfig;
            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 => {
                        if tag.wire_type()
                            == ::buffa::encoding::WireType::LengthDelimited
                        {
                            let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                            view.orderbook_price_buckets.reserve(payload.len() / 8usize);
                            let mut pcur: &[u8] = payload;
                            while !pcur.is_empty() {
                                view.orderbook_price_buckets
                                    .push(::buffa::types::decode_double(&mut pcur)?);
                            }
                        } else if tag.wire_type() == ::buffa::encoding::WireType::Fixed64
                        {
                            view.orderbook_price_buckets
                                .push(::buffa::types::decode_double(&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::PairMarketdataConfig,
                ::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::PairMarketdataConfig,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::PairMarketdataConfig {
                    orderbook_price_buckets: self.orderbook_price_buckets.to_vec(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for PairMarketdataConfigView<'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.orderbook_price_buckets.is_empty() {
                    let payload: u32 = self.orderbook_price_buckets.len() as u32
                        * ::buffa::types::FIXED64_ENCODED_LEN as u32;
                    size
                        += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
                            + payload;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if !self.orderbook_price_buckets.is_empty() {
                    let payload: u32 = self.orderbook_price_buckets.len() as u32
                        * ::buffa::types::FIXED64_ENCODED_LEN as u32;
                    ::buffa::types::put_len_delimited_header(1u32, payload, buf);
                    for &v in &self.orderbook_price_buckets {
                        ::buffa::types::encode_double(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 PairMarketdataConfigView<'__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.orderbook_price_buckets.is_empty() {
                    __map
                        .serialize_entry(
                            "orderbookPriceBuckets",
                            &::buffa::json_helpers::RepeatedJson(
                                &self.orderbook_price_buckets,
                            ),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for PairMarketdataConfigView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "PairMarketdataConfig";
            const FULL_NAME: &'static str = "marketdata.v1.PairMarketdataConfig";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.PairMarketdataConfig";
        }
        ::buffa::impl_default_view_instance!(PairMarketdataConfigView);
        ::buffa::impl_view_reborrow!(PairMarketdataConfigView);
        /** Self-contained, `'static` owned view of a `PairMarketdataConfig` message.

 Wraps [`::buffa::OwnedView`]`<`[`PairMarketdataConfigView`]`<'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 [`PairMarketdataConfigView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct PairMarketdataConfigOwnedView(
            ::buffa::OwnedView<PairMarketdataConfigView<'static>>,
        );
        impl PairMarketdataConfigOwnedView {
            /// 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(
                    PairMarketdataConfigOwnedView(::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(
                    PairMarketdataConfigOwnedView(
                        ::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::PairMarketdataConfig,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    PairMarketdataConfigOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`PairMarketdataConfigView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &PairMarketdataConfigView<'_> {
                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::PairMarketdataConfig,
                ::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()
            }
            /// Suggested order book aggregation bucket sizes in quote-asset price units,
            /// e.g. 0.01, 0.1, 1, or 10.
            ///
            /// Field 1: `orderbook_price_buckets`
            #[must_use]
            pub fn orderbook_price_buckets(&self) -> &::buffa::RepeatedView<'_, f64> {
                &self.0.reborrow().orderbook_price_buckets
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<PairMarketdataConfigView<'static>>>
        for PairMarketdataConfigOwnedView {
            fn from(
                inner: ::buffa::OwnedView<PairMarketdataConfigView<'static>>,
            ) -> Self {
                PairMarketdataConfigOwnedView(inner)
            }
        }
        impl ::core::convert::From<PairMarketdataConfigOwnedView>
        for ::buffa::OwnedView<PairMarketdataConfigView<'static>> {
            fn from(wrapper: PairMarketdataConfigOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<PairMarketdataConfigView<'static>>,
        > for PairMarketdataConfigOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<PairMarketdataConfigView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::PairMarketdataConfig {
            type View<'a> = PairMarketdataConfigView<'a>;
            type ViewHandle = PairMarketdataConfigOwnedView;
        }
        impl ::serde::Serialize for PairMarketdataConfigOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// PairConfig describes one spot trading pair and its trading constraints.
        #[derive(Clone, Debug, Default)]
        pub struct PairConfigView<'a> {
            /// Stable numeric pair id used by low-latency ConnectRPC requests and streams.
            ///
            /// Field 1: `symbol_id`
            pub symbol_id: u32,
            /// Trading pair symbol, e.g. "BTC-USDT".
            ///
            /// Field 2: `symbol`
            pub symbol: &'a str,
            /// Base asset code. For BTC-USDT, this is "BTC".
            ///
            /// Field 3: `base_asset`
            pub base_asset: &'a str,
            /// Quote asset code. For BTC-USDT, this is "USDT".
            ///
            /// Field 4: `quote_asset`
            pub quote_asset: &'a str,
            /// Minimum allowed price increment as a decimal string in quote-asset units.
            /// Prices use 6 decimal places in scaled integer fields; for example "0.01"
            /// means orders must be priced in 0.01 quote-asset increments.
            ///
            /// Field 5: `tick_size`
            pub tick_size: &'a str,
            /// Minimum allowed quantity increment as a decimal string in base-asset units.
            ///
            /// Field 6: `step_size`
            pub step_size: &'a str,
            /// Minimum order notional as a decimal string in quote-asset units.
            ///
            /// Field 7: `min_notional_quote`
            pub min_notional_quote: &'a str,
            /// Minimum order quantity as a decimal string in base-asset units.
            ///
            /// Field 8: `min_qty_base`
            pub min_qty_base: &'a str,
            /// Whether BUY order fees may be paid from the base asset instead of the
            /// spent quote asset when the order request selects the base fee asset.
            ///
            /// Field 9: `allow_buy_fee_from_base`
            pub allow_buy_fee_from_base: bool,
            /// Quantity scale for base-asset amounts in this pair.
            ///
            /// Field 10: `base_quantity_scale`
            pub base_quantity_scale: u32,
            /// Quantity scale for quote-asset amounts in this pair.
            ///
            /// Field 11: `quote_quantity_scale`
            pub quote_quantity_scale: u32,
            /// Market-data display settings for this pair.
            ///
            /// Field 12: `marketdata`
            pub marketdata: ::buffa::MessageFieldView<
                super::super::__buffa::view::PairMarketdataConfigView<'a>,
            >,
            /// Scheduled listing timestamp. When unset, the pair has no explicit future
            /// listing time.
            ///
            /// Field 13: `listing_at`
            pub listing_at: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Scheduled delisting timestamp. When unset, the pair has no explicit
            /// delisting time.
            ///
            /// Field 14: `delisting_at`
            pub delisting_at: ::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'a>,
            >,
            /// Current trading status.
            ///
            /// Field 15: `status`
            pub status: ::buffa::EnumValue<super::super::PairStatus>,
            /// Default MARKET order slippage cap for BUY orders, in basis points
            /// (1 bp = 0.01%). A request-level slippage setting can override this value.
            ///
            /// Field 16: `default_market_slippage_bps_buy`
            pub default_market_slippage_bps_buy: i32,
            /// Default MARKET order slippage cap for SELL orders, in basis points
            /// (1 bp = 0.01%). A request-level slippage setting can override this value.
            ///
            /// Field 17: `default_market_slippage_bps_sell`
            pub default_market_slippage_bps_sell: i32,
            /// Maximum allowed drift between client reference price and server reference
            /// price for MARKET orders, in basis points (1 bp = 0.01%), when client
            /// reference pricing is used.
            ///
            /// Field 18: `max_client_ref_drift_bps`
            pub max_client_ref_drift_bps: i32,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for PairConfigView<'a> {
            type Owned = super::super::PairConfig;
            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::LengthDelimited,
                        )?;
                        view.base_asset = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    4u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.quote_asset = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    5u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.tick_size = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    6u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.step_size = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    7u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.min_notional_quote = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    8u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.min_qty_base = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    9u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.allow_buy_fee_from_base = ::buffa::types::decode_bool(
                            &mut cur,
                        )?;
                    }
                    10u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.base_quantity_scale = ::buffa::types::decode_uint32(
                            &mut cur,
                        )?;
                    }
                    11u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.quote_quantity_scale = ::buffa::types::decode_uint32(
                            &mut cur,
                        )?;
                    }
                    12u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.marketdata.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.marketdata = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::PairMarketdataConfigView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    13u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.listing_at.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.listing_at = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    14u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.delisting_at.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.delisting_at = ::buffa::MessageFieldView::set(
                                    <::buffa_types::google::protobuf::__buffa::view::TimestampView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    15u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.status = ::buffa::EnumValue::from(
                            ::buffa::types::decode_int32(&mut cur)?,
                        );
                    }
                    16u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.default_market_slippage_bps_buy = ::buffa::types::decode_int32(
                            &mut cur,
                        )?;
                    }
                    17u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.default_market_slippage_bps_sell = ::buffa::types::decode_int32(
                            &mut cur,
                        )?;
                    }
                    18u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.max_client_ref_drift_bps = ::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::PairConfig, ::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::PairConfig, ::buffa::DecodeError> {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::PairConfig {
                    symbol_id: self.symbol_id,
                    symbol: self.symbol.to_string(),
                    base_asset: self.base_asset.to_string(),
                    quote_asset: self.quote_asset.to_string(),
                    tick_size: self.tick_size.to_string(),
                    step_size: self.step_size.to_string(),
                    min_notional_quote: self.min_notional_quote.to_string(),
                    min_qty_base: self.min_qty_base.to_string(),
                    allow_buy_fee_from_base: self.allow_buy_fee_from_base,
                    base_quantity_scale: self.base_quantity_scale,
                    quote_quantity_scale: self.quote_quantity_scale,
                    marketdata: match self.marketdata.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::PairMarketdataConfig,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    listing_at: match self.listing_at.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    delisting_at: match self.delisting_at.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                ::buffa_types::google::protobuf::Timestamp,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    status: self.status,
                    default_market_slippage_bps_buy: self
                        .default_market_slippage_bps_buy,
                    default_market_slippage_bps_sell: self
                        .default_market_slippage_bps_sell,
                    max_client_ref_drift_bps: self.max_client_ref_drift_bps,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for PairConfigView<'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.base_asset.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.base_asset)
                                as u32;
                }
                if !self.quote_asset.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.quote_asset)
                                as u32;
                }
                if !self.tick_size.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.tick_size) as u32;
                }
                if !self.step_size.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.step_size) as u32;
                }
                if !self.min_notional_quote.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(
                                &self.min_notional_quote,
                            ) as u32;
                }
                if !self.min_qty_base.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.min_qty_base)
                                as u32;
                }
                if self.allow_buy_fee_from_base {
                    size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
                }
                if self.base_quantity_scale != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(
                                self.base_quantity_scale,
                            ) as u32;
                }
                if self.quote_quantity_scale != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(
                                self.quote_quantity_scale,
                            ) as u32;
                }
                if self.marketdata.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.marketdata.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.listing_at.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.listing_at.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                if self.delisting_at.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.delisting_at.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                {
                    let val = self.status.to_i32();
                    if val != 0 {
                        size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
                    }
                }
                if self.default_market_slippage_bps_buy != 0i32 {
                    size
                        += 2u32
                            + ::buffa::types::int32_encoded_len(
                                self.default_market_slippage_bps_buy,
                            ) as u32;
                }
                if self.default_market_slippage_bps_sell != 0i32 {
                    size
                        += 2u32
                            + ::buffa::types::int32_encoded_len(
                                self.default_market_slippage_bps_sell,
                            ) as u32;
                }
                if self.max_client_ref_drift_bps != 0i32 {
                    size
                        += 2u32
                            + ::buffa::types::int32_encoded_len(
                                self.max_client_ref_drift_bps,
                            ) 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.base_asset.is_empty() {
                    ::buffa::types::put_string_field(3u32, &self.base_asset, buf);
                }
                if !self.quote_asset.is_empty() {
                    ::buffa::types::put_string_field(4u32, &self.quote_asset, buf);
                }
                if !self.tick_size.is_empty() {
                    ::buffa::types::put_string_field(5u32, &self.tick_size, buf);
                }
                if !self.step_size.is_empty() {
                    ::buffa::types::put_string_field(6u32, &self.step_size, buf);
                }
                if !self.min_notional_quote.is_empty() {
                    ::buffa::types::put_string_field(
                        7u32,
                        &self.min_notional_quote,
                        buf,
                    );
                }
                if !self.min_qty_base.is_empty() {
                    ::buffa::types::put_string_field(8u32, &self.min_qty_base, buf);
                }
                if self.allow_buy_fee_from_base {
                    ::buffa::types::put_bool_field(
                        9u32,
                        self.allow_buy_fee_from_base,
                        buf,
                    );
                }
                if self.base_quantity_scale != 0u32 {
                    ::buffa::types::put_uint32_field(
                        10u32,
                        self.base_quantity_scale,
                        buf,
                    );
                }
                if self.quote_quantity_scale != 0u32 {
                    ::buffa::types::put_uint32_field(
                        11u32,
                        self.quote_quantity_scale,
                        buf,
                    );
                }
                if self.marketdata.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        12u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.marketdata.write_to(__cache, buf);
                }
                if self.listing_at.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        13u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.listing_at.write_to(__cache, buf);
                }
                if self.delisting_at.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        14u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.delisting_at.write_to(__cache, buf);
                }
                {
                    let val = self.status.to_i32();
                    if val != 0 {
                        ::buffa::types::put_int32_field(15u32, val, buf);
                    }
                }
                if self.default_market_slippage_bps_buy != 0i32 {
                    ::buffa::types::put_int32_field(
                        16u32,
                        self.default_market_slippage_bps_buy,
                        buf,
                    );
                }
                if self.default_market_slippage_bps_sell != 0i32 {
                    ::buffa::types::put_int32_field(
                        17u32,
                        self.default_market_slippage_bps_sell,
                        buf,
                    );
                }
                if self.max_client_ref_drift_bps != 0i32 {
                    ::buffa::types::put_int32_field(
                        18u32,
                        self.max_client_ref_drift_bps,
                        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 PairConfigView<'__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_empty_str(self.base_asset) {
                    __map.serialize_entry("baseAsset", self.base_asset)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.quote_asset) {
                    __map.serialize_entry("quoteAsset", self.quote_asset)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.tick_size) {
                    __map.serialize_entry("tickSize", self.tick_size)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.step_size) {
                    __map.serialize_entry("stepSize", self.step_size)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(
                    self.min_notional_quote,
                ) {
                    __map.serialize_entry("minNotionalQuote", self.min_notional_quote)?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.min_qty_base) {
                    __map.serialize_entry("minQtyBase", self.min_qty_base)?;
                }
                if self.allow_buy_fee_from_base {
                    __map
                        .serialize_entry(
                            "allowBuyFeeFromBase",
                            &self.allow_buy_fee_from_base,
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(
                    &self.base_quantity_scale,
                ) {
                    __map
                        .serialize_entry(
                            "baseQuantityScale",
                            &::buffa::json_helpers::ProtoJson(&self.base_quantity_scale),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(
                    &self.quote_quantity_scale,
                ) {
                    __map
                        .serialize_entry(
                            "quoteQuantityScale",
                            &::buffa::json_helpers::ProtoJson(&self.quote_quantity_scale),
                        )?;
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .marketdata
                        .as_option()
                    {
                        __map.serialize_entry("marketdata", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .listing_at
                        .as_option()
                    {
                        __map.serialize_entry("listingAt", __v)?;
                    }
                }
                {
                    if let ::core::option::Option::Some(__v) = self
                        .delisting_at
                        .as_option()
                    {
                        __map.serialize_entry("delistingAt", __v)?;
                    }
                }
                if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.status) {
                    __map.serialize_entry("status", &self.status)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i32(
                    &self.default_market_slippage_bps_buy,
                ) {
                    __map
                        .serialize_entry(
                            "defaultMarketSlippageBpsBuy",
                            &::buffa::json_helpers::ProtoJson(
                                &self.default_market_slippage_bps_buy,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i32(
                    &self.default_market_slippage_bps_sell,
                ) {
                    __map
                        .serialize_entry(
                            "defaultMarketSlippageBpsSell",
                            &::buffa::json_helpers::ProtoJson(
                                &self.default_market_slippage_bps_sell,
                            ),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_i32(
                    &self.max_client_ref_drift_bps,
                ) {
                    __map
                        .serialize_entry(
                            "maxClientRefDriftBps",
                            &::buffa::json_helpers::ProtoJson(
                                &self.max_client_ref_drift_bps,
                            ),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for PairConfigView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "PairConfig";
            const FULL_NAME: &'static str = "marketdata.v1.PairConfig";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.PairConfig";
        }
        ::buffa::impl_default_view_instance!(PairConfigView);
        ::buffa::impl_view_reborrow!(PairConfigView);
        /** Self-contained, `'static` owned view of a `PairConfig` message.

 Wraps [`::buffa::OwnedView`]`<`[`PairConfigView`]`<'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 [`PairConfigView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct PairConfigOwnedView(::buffa::OwnedView<PairConfigView<'static>>);
        impl PairConfigOwnedView {
            /// 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(
                    PairConfigOwnedView(::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(
                    PairConfigOwnedView(
                        ::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::PairConfig,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    PairConfigOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`PairConfigView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &PairConfigView<'_> {
                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::PairConfig, ::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 numeric pair id used by low-latency ConnectRPC requests and streams.
            ///
            /// Field 1: `symbol_id`
            #[must_use]
            pub fn symbol_id(&self) -> u32 {
                self.0.reborrow().symbol_id
            }
            /// Trading pair symbol, e.g. "BTC-USDT".
            ///
            /// Field 2: `symbol`
            #[must_use]
            pub fn symbol(&self) -> &'_ str {
                self.0.reborrow().symbol
            }
            /// Base asset code. For BTC-USDT, this is "BTC".
            ///
            /// Field 3: `base_asset`
            #[must_use]
            pub fn base_asset(&self) -> &'_ str {
                self.0.reborrow().base_asset
            }
            /// Quote asset code. For BTC-USDT, this is "USDT".
            ///
            /// Field 4: `quote_asset`
            #[must_use]
            pub fn quote_asset(&self) -> &'_ str {
                self.0.reborrow().quote_asset
            }
            /// Minimum allowed price increment as a decimal string in quote-asset units.
            /// Prices use 6 decimal places in scaled integer fields; for example "0.01"
            /// means orders must be priced in 0.01 quote-asset increments.
            ///
            /// Field 5: `tick_size`
            #[must_use]
            pub fn tick_size(&self) -> &'_ str {
                self.0.reborrow().tick_size
            }
            /// Minimum allowed quantity increment as a decimal string in base-asset units.
            ///
            /// Field 6: `step_size`
            #[must_use]
            pub fn step_size(&self) -> &'_ str {
                self.0.reborrow().step_size
            }
            /// Minimum order notional as a decimal string in quote-asset units.
            ///
            /// Field 7: `min_notional_quote`
            #[must_use]
            pub fn min_notional_quote(&self) -> &'_ str {
                self.0.reborrow().min_notional_quote
            }
            /// Minimum order quantity as a decimal string in base-asset units.
            ///
            /// Field 8: `min_qty_base`
            #[must_use]
            pub fn min_qty_base(&self) -> &'_ str {
                self.0.reborrow().min_qty_base
            }
            /// Whether BUY order fees may be paid from the base asset instead of the
            /// spent quote asset when the order request selects the base fee asset.
            ///
            /// Field 9: `allow_buy_fee_from_base`
            #[must_use]
            pub fn allow_buy_fee_from_base(&self) -> bool {
                self.0.reborrow().allow_buy_fee_from_base
            }
            /// Quantity scale for base-asset amounts in this pair.
            ///
            /// Field 10: `base_quantity_scale`
            #[must_use]
            pub fn base_quantity_scale(&self) -> u32 {
                self.0.reborrow().base_quantity_scale
            }
            /// Quantity scale for quote-asset amounts in this pair.
            ///
            /// Field 11: `quote_quantity_scale`
            #[must_use]
            pub fn quote_quantity_scale(&self) -> u32 {
                self.0.reborrow().quote_quantity_scale
            }
            /// Market-data display settings for this pair.
            ///
            /// Field 12: `marketdata`
            #[must_use]
            pub fn marketdata(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::PairMarketdataConfigView<'_>,
            > {
                &self.0.reborrow().marketdata
            }
            /// Scheduled listing timestamp. When unset, the pair has no explicit future
            /// listing time.
            ///
            /// Field 13: `listing_at`
            #[must_use]
            pub fn listing_at(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().listing_at
            }
            /// Scheduled delisting timestamp. When unset, the pair has no explicit
            /// delisting time.
            ///
            /// Field 14: `delisting_at`
            #[must_use]
            pub fn delisting_at(
                &self,
            ) -> &::buffa::MessageFieldView<
                ::buffa_types::google::protobuf::__buffa::view::TimestampView<'_>,
            > {
                &self.0.reborrow().delisting_at
            }
            /// Current trading status.
            ///
            /// Field 15: `status`
            #[must_use]
            pub fn status(&self) -> ::buffa::EnumValue<super::super::PairStatus> {
                self.0.reborrow().status
            }
            /// Default MARKET order slippage cap for BUY orders, in basis points
            /// (1 bp = 0.01%). A request-level slippage setting can override this value.
            ///
            /// Field 16: `default_market_slippage_bps_buy`
            #[must_use]
            pub fn default_market_slippage_bps_buy(&self) -> i32 {
                self.0.reborrow().default_market_slippage_bps_buy
            }
            /// Default MARKET order slippage cap for SELL orders, in basis points
            /// (1 bp = 0.01%). A request-level slippage setting can override this value.
            ///
            /// Field 17: `default_market_slippage_bps_sell`
            #[must_use]
            pub fn default_market_slippage_bps_sell(&self) -> i32 {
                self.0.reborrow().default_market_slippage_bps_sell
            }
            /// Maximum allowed drift between client reference price and server reference
            /// price for MARKET orders, in basis points (1 bp = 0.01%), when client
            /// reference pricing is used.
            ///
            /// Field 18: `max_client_ref_drift_bps`
            #[must_use]
            pub fn max_client_ref_drift_bps(&self) -> i32 {
                self.0.reborrow().max_client_ref_drift_bps
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<PairConfigView<'static>>>
        for PairConfigOwnedView {
            fn from(inner: ::buffa::OwnedView<PairConfigView<'static>>) -> Self {
                PairConfigOwnedView(inner)
            }
        }
        impl ::core::convert::From<PairConfigOwnedView>
        for ::buffa::OwnedView<PairConfigView<'static>> {
            fn from(wrapper: PairConfigOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<PairConfigView<'static>>>
        for PairConfigOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<PairConfigView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::PairConfig {
            type View<'a> = PairConfigView<'a>;
            type ViewHandle = PairConfigOwnedView;
        }
        impl ::serde::Serialize for PairConfigOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetSpotConfigRequest has no parameters.
        #[derive(Clone, Debug, Default)]
        pub struct GetSpotConfigRequestView<'a> {
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetSpotConfigRequestView<'a> {
            type Owned = super::super::GetSpotConfigRequest;
            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() {
                    _ => {
                        ::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::GetSpotConfigRequest,
                ::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::GetSpotConfigRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetSpotConfigRequest {
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetSpotConfigRequestView<'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;
                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 _;
                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 GetSpotConfigRequestView<'__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)?;
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetSpotConfigRequestView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetSpotConfigRequest";
            const FULL_NAME: &'static str = "marketdata.v1.GetSpotConfigRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetSpotConfigRequest";
        }
        ::buffa::impl_default_view_instance!(GetSpotConfigRequestView);
        ::buffa::impl_view_reborrow!(GetSpotConfigRequestView);
        /** Self-contained, `'static` owned view of a `GetSpotConfigRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetSpotConfigRequestView`]`<'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 [`GetSpotConfigRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetSpotConfigRequestOwnedView(
            ::buffa::OwnedView<GetSpotConfigRequestView<'static>>,
        );
        impl GetSpotConfigRequestOwnedView {
            /// 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(
                    GetSpotConfigRequestOwnedView(::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(
                    GetSpotConfigRequestOwnedView(
                        ::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::GetSpotConfigRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetSpotConfigRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetSpotConfigRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetSpotConfigRequestView<'_> {
                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::GetSpotConfigRequest,
                ::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()
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<GetSpotConfigRequestView<'static>>>
        for GetSpotConfigRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetSpotConfigRequestView<'static>>,
            ) -> Self {
                GetSpotConfigRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetSpotConfigRequestOwnedView>
        for ::buffa::OwnedView<GetSpotConfigRequestView<'static>> {
            fn from(wrapper: GetSpotConfigRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetSpotConfigRequestView<'static>>,
        > for GetSpotConfigRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetSpotConfigRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetSpotConfigRequest {
            type View<'a> = GetSpotConfigRequestView<'a>;
            type ViewHandle = GetSpotConfigRequestOwnedView;
        }
        impl ::serde::Serialize for GetSpotConfigRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// GetSpotConfigResponse contains a cacheable spot reference-data snapshot.
        #[derive(Clone, Debug, Default)]
        pub struct GetSpotConfigResponseView<'a> {
            /// Assets ordered by asset code in ascending alphabetical order.
            ///
            /// Field 1: `assets`
            pub assets: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::AssetConfigView<'a>,
            >,
            /// Pairs ordered by symbol in ascending alphabetical order.
            ///
            /// Field 2: `pairs`
            pub pairs: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::PairConfigView<'a>,
            >,
            /// Snapshot generation timestamp, in seconds since the Unix epoch (UTC).
            ///
            /// Field 3: `ts_sec`
            pub ts_sec: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for GetSpotConfigResponseView<'a> {
            type Owned = super::super::GetSpotConfigResponse;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    3u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.ts_sec = ::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.assets
                            .push(
                                <super::super::__buffa::view::AssetConfigView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.pairs
                            .push(
                                <super::super::__buffa::view::PairConfigView 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::GetSpotConfigResponse,
                ::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::GetSpotConfigResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::GetSpotConfigResponse {
                    assets: self
                        .assets
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    pairs: self
                        .pairs
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    ts_sec: self.ts_sec,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for GetSpotConfigResponseView<'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.assets {
                    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;
                }
                for v in &self.pairs {
                    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_sec != 0u64 {
                    size
                        += 1u32 + ::buffa::types::uint64_encoded_len(self.ts_sec) 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.assets {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                for v in &self.pairs {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                if self.ts_sec != 0u64 {
                    ::buffa::types::put_uint64_field(3u32, self.ts_sec, 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 GetSpotConfigResponseView<'__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.assets.is_empty() {
                    __map.serialize_entry("assets", &*self.assets)?;
                }
                if !self.pairs.is_empty() {
                    __map.serialize_entry("pairs", &*self.pairs)?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.ts_sec) {
                    __map
                        .serialize_entry(
                            "tsSec",
                            &::buffa::json_helpers::ProtoJson(&self.ts_sec),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for GetSpotConfigResponseView<'a> {
            const PACKAGE: &'static str = "marketdata.v1";
            const NAME: &'static str = "GetSpotConfigResponse";
            const FULL_NAME: &'static str = "marketdata.v1.GetSpotConfigResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/marketdata.v1.GetSpotConfigResponse";
        }
        ::buffa::impl_default_view_instance!(GetSpotConfigResponseView);
        ::buffa::impl_view_reborrow!(GetSpotConfigResponseView);
        /** Self-contained, `'static` owned view of a `GetSpotConfigResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`GetSpotConfigResponseView`]`<'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 [`GetSpotConfigResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct GetSpotConfigResponseOwnedView(
            ::buffa::OwnedView<GetSpotConfigResponseView<'static>>,
        );
        impl GetSpotConfigResponseOwnedView {
            /// 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(
                    GetSpotConfigResponseOwnedView(::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(
                    GetSpotConfigResponseOwnedView(
                        ::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::GetSpotConfigResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    GetSpotConfigResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`GetSpotConfigResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &GetSpotConfigResponseView<'_> {
                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::GetSpotConfigResponse,
                ::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()
            }
            /// Assets ordered by asset code in ascending alphabetical order.
            ///
            /// Field 1: `assets`
            #[must_use]
            pub fn assets(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::AssetConfigView<'_>,
            > {
                &self.0.reborrow().assets
            }
            /// Pairs ordered by symbol in ascending alphabetical order.
            ///
            /// Field 2: `pairs`
            #[must_use]
            pub fn pairs(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::PairConfigView<'_>,
            > {
                &self.0.reborrow().pairs
            }
            /// Snapshot generation timestamp, in seconds since the Unix epoch (UTC).
            ///
            /// Field 3: `ts_sec`
            #[must_use]
            pub fn ts_sec(&self) -> u64 {
                self.0.reborrow().ts_sec
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<GetSpotConfigResponseView<'static>>,
        > for GetSpotConfigResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<GetSpotConfigResponseView<'static>>,
            ) -> Self {
                GetSpotConfigResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<GetSpotConfigResponseOwnedView>
        for ::buffa::OwnedView<GetSpotConfigResponseView<'static>> {
            fn from(wrapper: GetSpotConfigResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<GetSpotConfigResponseView<'static>>,
        > for GetSpotConfigResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<GetSpotConfigResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::GetSpotConfigResponse {
            type View<'a> = GetSpotConfigResponseView<'a>;
            type ViewHandle = GetSpotConfigResponseOwnedView;
        }
        impl ::serde::Serialize for GetSpotConfigResponseOwnedView {
            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::__HEATMAP_TIME_RANGE_JSON_ANY);
        reg.register_json_any(super::__GET_ORDERBOOK_HEATMAP_REQUEST_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_LEVELS_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_DELTA_LEVELS_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_KEYFRAME_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_DELTA_BUCKET_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_LIVE_BUCKET_JSON_ANY);
        reg.register_json_any(super::__HEATMAP_DELTA_CHAIN_JSON_ANY);
        reg.register_json_any(super::__GET_ORDERBOOK_HEATMAP_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__GET_TRADES_REQUEST_JSON_ANY);
        reg.register_json_any(super::__MARKET_TRADE_JSON_ANY);
        reg.register_json_any(super::__GET_TRADES_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__GET_CANDLES_REQUEST_JSON_ANY);
        reg.register_json_any(super::__GET_CANDLES_COLUMNS_REQUEST_JSON_ANY);
        reg.register_json_any(super::__CANDLE_POINT_JSON_ANY);
        reg.register_json_any(super::__GET_CANDLES_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__GET_CANDLES_COLUMNS_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__CANDLE_JSON_ANY);
        reg.register_json_any(super::__ASSET_CONFIG_JSON_ANY);
        reg.register_json_any(super::__PAIR_MARKETDATA_CONFIG_JSON_ANY);
        reg.register_json_any(super::__PAIR_CONFIG_JSON_ANY);
        reg.register_json_any(super::__GET_SPOT_CONFIG_REQUEST_JSON_ANY);
        reg.register_json_any(super::__GET_SPOT_CONFIG_RESPONSE_JSON_ANY);
    }
}
#[doc(inline)]
pub use self::__buffa::view::HeatmapTimeRangeView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapTimeRangeOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetOrderbookHeatmapRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetOrderbookHeatmapRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapLevelsView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapLevelsOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaLevelsView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaLevelsOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapKeyframeView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapKeyframeOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaBucketView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaBucketOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapLiveBucketView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapLiveBucketOwnedView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaChainView;
#[doc(inline)]
pub use self::__buffa::view::HeatmapDeltaChainOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetOrderbookHeatmapResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetOrderbookHeatmapResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetTradesRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetTradesRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::MarketTradeView;
#[doc(inline)]
pub use self::__buffa::view::MarketTradeOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetTradesResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetTradesResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesColumnsRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesColumnsRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::CandlePointView;
#[doc(inline)]
pub use self::__buffa::view::CandlePointOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesColumnsResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetCandlesColumnsResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::CandleView;
#[doc(inline)]
pub use self::__buffa::view::CandleOwnedView;
#[doc(inline)]
pub use self::__buffa::view::AssetConfigView;
#[doc(inline)]
pub use self::__buffa::view::AssetConfigOwnedView;
#[doc(inline)]
pub use self::__buffa::view::PairMarketdataConfigView;
#[doc(inline)]
pub use self::__buffa::view::PairMarketdataConfigOwnedView;
#[doc(inline)]
pub use self::__buffa::view::PairConfigView;
#[doc(inline)]
pub use self::__buffa::view::PairConfigOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetSpotConfigRequestView;
#[doc(inline)]
pub use self::__buffa::view::GetSpotConfigRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::GetSpotConfigResponseView;
#[doc(inline)]
pub use self::__buffa::view::GetSpotConfigResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::register_types;