exoware-sdk 2026.9.0

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

/// Batch write request. All pairs are applied atomically.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct PutRequest {
    /// Key-value pairs to write. At least one pair is required.
    ///
    /// Field 1: `kvs`
    #[serde(
        rename = "kvs",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub kvs: ::buffa::alloc::vec::Vec<super::super::super::common::kv::v1::Entry>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for PutRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("PutRequest").field("kvs", &self.kvs).finish()
    }
}
impl PutRequest {
    /// 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/log.ingest.v1.PutRequest";
}
::buffa::impl_default_instance!(PutRequest);
impl ::buffa::MessageName for PutRequest {
    const PACKAGE: &'static str = "log.ingest.v1";
    const NAME: &'static str = "PutRequest";
    const FULL_NAME: &'static str = "log.ingest.v1.PutRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/log.ingest.v1.PutRequest";
}
impl ::buffa::Message for PutRequest {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.kvs {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.kvs {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.kvs.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.kvs.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for PutRequest {
    const PROTO_FQN: &'static str = "log.ingest.v1.PutRequest";
    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 PutRequest {
    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 __PUT_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/log.ingest.v1.PutRequest",
    to_json: ::buffa::type_registry::any_to_json::<PutRequest>,
    from_json: ::buffa::type_registry::any_from_json::<PutRequest>,
    is_wkt: false,
};
/// Response from a successful Put.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct PutResponse {
    /// Monotonically increasing store sequence number assigned to this write
    /// batch. Pass to query RPCs as `min_sequence_number` to ensure subsequent
    /// reads reflect this write.
    ///
    /// Field 1: `sequence_number`
    #[serde(
        rename = "sequenceNumber",
        alias = "sequence_number",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub sequence_number: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for PutResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("PutResponse")
            .field("sequence_number", &self.sequence_number)
            .finish()
    }
}
impl PutResponse {
    /// 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/log.ingest.v1.PutResponse";
}
::buffa::impl_default_instance!(PutResponse);
impl ::buffa::MessageName for PutResponse {
    const PACKAGE: &'static str = "log.ingest.v1";
    const NAME: &'static str = "PutResponse";
    const FULL_NAME: &'static str = "log.ingest.v1.PutResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/log.ingest.v1.PutResponse";
}
impl ::buffa::Message for PutResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.sequence_number != 0u64 {
            size
                += 1u64
                    + ::buffa::types::uint64_encoded_len(self.sequence_number) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.sequence_number != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.sequence_number, 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.sequence_number = ::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.sequence_number = 0u64;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for PutResponse {
    const PROTO_FQN: &'static str = "log.ingest.v1.PutResponse";
    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 PutResponse {
    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 __PUT_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/log.ingest.v1.PutResponse",
    to_json: ::buffa::type_registry::any_to_json::<PutResponse>,
    from_json: ::buffa::type_registry::any_from_json::<PutResponse>,
    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::*;
        /// Batch write request. All pairs are applied atomically.
        #[derive(Clone, Debug, Default)]
        pub struct PutRequestView<'a> {
            /// Key-value pairs to write. At least one pair is required.
            ///
            /// Field 1: `kvs`
            pub kvs: ::buffa::RepeatedView<
                'a,
                super::super::super::super::super::common::kv::v1::__buffa::view::EntryView<
                    'a,
                >,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for PutRequestView<'a> {
            type Owned = super::super::PutRequest;
            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)
            }
            #[inline]
            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)?;
                        ctx.register_element_memory(
                            ::core::mem::size_of::<
                                super::super::super::super::super::common::kv::v1::__buffa::view::EntryView,
                            >(),
                        )?;
                        view.kvs
                            .push(
                                <super::super::super::super::super::common::kv::v1::__buffa::view::EntryView 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::PutRequest, ::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::PutRequest, ::buffa::DecodeError> {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::PutRequest {
                    kvs: self
                        .kvs
                        .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 PutRequestView<'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 = 0u64;
                for v in &self.kvs {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                            + inner_size as u64;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u64;
                ::buffa::saturate_size(size)
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::EncodeSink,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                for v in &self.kvs {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__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 PutRequestView<'__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.kvs.is_empty() {
                    __map.serialize_entry("kvs", &*self.kvs)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for PutRequestView<'a> {
            const PACKAGE: &'static str = "log.ingest.v1";
            const NAME: &'static str = "PutRequest";
            const FULL_NAME: &'static str = "log.ingest.v1.PutRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/log.ingest.v1.PutRequest";
        }
        ::buffa::impl_default_view_instance!(PutRequestView);
        ::buffa::impl_view_reborrow!(PutRequestView);
        /** Self-contained, `'static` owned view of a `PutRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`PutRequestView`]`<'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 [`PutRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct PutRequestOwnedView(::buffa::OwnedView<PutRequestView<'static>>);
        impl PutRequestOwnedView {
            /// 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(
                    PutRequestOwnedView(::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(
                    PutRequestOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
            /// message's encoded size exceeds the 2 GiB protobuf limit, or
            /// another [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::PutRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    PutRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`PutRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &PutRequestView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// Infallible: this type's constructors wire-decode their
            /// buffer, and a view produced by wire decoding always
            /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
            /// whose contract also governs handles converted from a raw
            /// [`::buffa::OwnedView`].
            #[must_use]
            pub fn to_owned_message(&self) -> super::super::PutRequest {
                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()
            }
            /// Key-value pairs to write. At least one pair is required.
            ///
            /// Field 1: `kvs`
            #[must_use]
            pub fn kvs(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::super::super::super::common::kv::v1::__buffa::view::EntryView<
                    '_,
                >,
            > {
                &self.0.reborrow().kvs
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<PutRequestView<'static>>>
        for PutRequestOwnedView {
            fn from(inner: ::buffa::OwnedView<PutRequestView<'static>>) -> Self {
                PutRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<PutRequestOwnedView>
        for ::buffa::OwnedView<PutRequestView<'static>> {
            fn from(wrapper: PutRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<PutRequestView<'static>>>
        for PutRequestOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<PutRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::PutRequest {
            type View<'a> = PutRequestView<'a>;
            type ViewHandle = PutRequestOwnedView;
        }
        impl ::serde::Serialize for PutRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// Response from a successful Put.
        #[derive(Clone, Debug, Default)]
        pub struct PutResponseView<'a> {
            /// Monotonically increasing store sequence number assigned to this write
            /// batch. Pass to query RPCs as `min_sequence_number` to ensure subsequent
            /// reads reflect this write.
            ///
            /// Field 1: `sequence_number`
            pub sequence_number: u64,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for PutResponseView<'a> {
            type Owned = super::super::PutResponse;
            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)
            }
            #[inline]
            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.sequence_number = ::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::PutResponse,
                ::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::PutResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::PutResponse {
                    sequence_number: self.sequence_number,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for PutResponseView<'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 = 0u64;
                if self.sequence_number != 0u64 {
                    size
                        += 1u64
                            + ::buffa::types::uint64_encoded_len(self.sequence_number)
                                as u64;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u64;
                ::buffa::saturate_size(size)
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::EncodeSink,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.sequence_number != 0u64 {
                    ::buffa::types::put_uint64_field(1u32, self.sequence_number, 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 PutResponseView<'__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.sequence_number) {
                    __map
                        .serialize_entry(
                            "sequenceNumber",
                            &::buffa::json_helpers::ProtoJson(&self.sequence_number),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for PutResponseView<'a> {
            const PACKAGE: &'static str = "log.ingest.v1";
            const NAME: &'static str = "PutResponse";
            const FULL_NAME: &'static str = "log.ingest.v1.PutResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/log.ingest.v1.PutResponse";
        }
        ::buffa::impl_default_view_instance!(PutResponseView);
        ::buffa::impl_view_reborrow!(PutResponseView);
        /** Self-contained, `'static` owned view of a `PutResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`PutResponseView`]`<'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 [`PutResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct PutResponseOwnedView(::buffa::OwnedView<PutResponseView<'static>>);
        impl PutResponseOwnedView {
            /// 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(
                    PutResponseOwnedView(::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(
                    PutResponseOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
            /// message's encoded size exceeds the 2 GiB protobuf limit, or
            /// another [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::PutResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    PutResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`PutResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &PutResponseView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// Infallible: this type's constructors wire-decode their
            /// buffer, and a view produced by wire decoding always
            /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
            /// whose contract also governs handles converted from a raw
            /// [`::buffa::OwnedView`].
            #[must_use]
            pub fn to_owned_message(&self) -> super::super::PutResponse {
                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()
            }
            /// Monotonically increasing store sequence number assigned to this write
            /// batch. Pass to query RPCs as `min_sequence_number` to ensure subsequent
            /// reads reflect this write.
            ///
            /// Field 1: `sequence_number`
            #[must_use]
            pub fn sequence_number(&self) -> u64 {
                self.0.reborrow().sequence_number
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<PutResponseView<'static>>>
        for PutResponseOwnedView {
            fn from(inner: ::buffa::OwnedView<PutResponseView<'static>>) -> Self {
                PutResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<PutResponseOwnedView>
        for ::buffa::OwnedView<PutResponseView<'static>> {
            fn from(wrapper: PutResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<PutResponseView<'static>>>
        for PutResponseOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<PutResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::PutResponse {
            type View<'a> = PutResponseView<'a>;
            type ViewHandle = PutResponseOwnedView;
        }
        impl ::serde::Serialize for PutResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
    }
}
#[doc(inline)]
pub use self::__buffa::view::PutRequestView;
#[doc(inline)]
pub use self::__buffa::view::PutRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::PutResponseView;
#[doc(inline)]
pub use self::__buffa::view::PutResponseOwnedView;

///Shorthand for `OwnedView<PutRequestView<'static>>`.
pub type OwnedPutRequestView = ::buffa::view::OwnedView<
    __buffa::view::PutRequestView<'static>,
>;
///Shorthand for `OwnedView<PutResponseView<'static>>`.
pub type OwnedPutResponseView = ::buffa::view::OwnedView<
    __buffa::view::PutResponseView<'static>,
>;
impl ::connectrpc::Encodable<PutResponse> for __buffa::view::PutResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<PutResponse>
for ::buffa::view::OwnedView<__buffa::view::PutResponseView<'static>> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
/// Full service name for this service.
pub const SERVICE_SERVICE_NAME: &str = "log.ingest.v1.Service";
/// Static [`Spec`](::connectrpc::Spec) for the `Put` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const SERVICE_PUT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/log.ingest.v1.Service/Put",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Ingest service for writing key-value pairs into the store.
///
/// # Implementing handlers
///
/// Implement methods with plain `async fn`; the returned future satisfies
/// the `Send` bound automatically.
///
/// **Unary and server-streaming requests** arrive as
/// [`ServiceRequest<'_, Req>`](::connectrpc::ServiceRequest): a zero-copy
/// view of the request plus its body, valid for the duration of the call.
/// Fields are read directly (`request.name` is a `&str` into the decoded
/// buffer) and the borrow may be held across `.await` points. Anything
/// that must outlive the call — `tokio::spawn`, channels, server state,
/// or data captured by a returned response stream — takes owned data:
/// call `request.to_owned_message()` (or copy the specific fields)
/// first.
///
/// **Client-streaming and bidi requests** arrive as
/// [`InboundStream<Req>`](::connectrpc::InboundStream) — a
/// `ServiceStream` of [`StreamMessage`](::connectrpc::StreamMessage)s.
/// Each item owns its decoded buffer and is `Send + 'static`, so items
/// can be buffered or moved into spawned tasks; read fields zero-copy
/// through the generated accessor methods (`item.name()`) or `.view()`,
/// convert with `.to_owned_message()`, or yield an item back unchanged —
/// `StreamMessage<M>` implements `Encodable<M>`.
///
/// Request types resolved through `extern_path` (e.g. well-known types
/// from another crate) use the same wrappers; the crate that owns the
/// type must be generated with buffa ≥ 0.9.0 and views enabled so the
/// backing `HasMessageView` impl exists.
///
/// The `impl Encodable<Out>` return bound accepts the owned `Out`, the
/// generated `OutView<'_>` / `OwnedOutView`,
/// [`MaybeBorrowed`](::connectrpc::MaybeBorrowed), or
/// [`PreEncoded`](::connectrpc::PreEncoded) for handlers that encode a
/// non-`'static` view internally and pass the bytes across the handler
/// boundary. View bodies are not emitted for output types mapped via
/// `extern_path` (the impl would be an orphan); return owned for
/// WKT/extern outputs.
///
/// Server-streaming and bidi-streaming methods return
/// `ServiceStream<impl Encodable<Out> + Send + use<Self>>`. The
/// `use<Self>` precise-capturing clause excludes `&self`'s lifetime and
/// the request's lifetime (unary methods use `use<'a, Self>` and may
/// borrow from `&self`), so stream items must be `'static` and cannot
/// borrow from the request. To stream view-encoded data, encode each
/// item inside the stream body and yield
/// [`PreEncoded`](::connectrpc::PreEncoded) — see its `# Streaming
/// example` doc.
#[allow(clippy::type_complexity)]
pub trait Service: Send + Sync + 'static {
    /// Atomically write a batch of key-value pairs. On success the entire batch
    /// is persisted and the response carries the store sequence number that
    /// covers this write. Clients can pass that sequence number to query RPCs
    /// (via `min_sequence_number`) for read-after-write consistency.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn put<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<'_, PutRequest>,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<PutResponse> + Send + use<'a, Self>,
        >,
    > + Send;
}
/// Extension trait for registering a service implementation with a Router.
///
/// This trait is automatically implemented for all types that implement the service trait.
/// Prefer [`Router::add_service`](::connectrpc::Router::add_service) for
/// top-down registration; `register` remains available for compatibility
/// and cases where the service-first call shape is more convenient.
///
/// # Example
///
/// ```rust,ignore
/// use std::sync::Arc;
///
/// let service = Arc::new(MyServiceImpl);
/// let router = service.register(Router::new());
/// ```
pub trait ServiceExt: Service {
    /// Register this service implementation with a Router.
    ///
    /// Takes ownership of the `Arc<Self>` and returns a new Router with
    /// this service's methods registered.
    fn register(
        self: ::std::sync::Arc<Self>,
        router: ::connectrpc::Router,
    ) -> ::connectrpc::Router;
}
impl<S: Service> ServiceExt for S {
    fn register(
        self: ::std::sync::Arc<Self>,
        router: ::connectrpc::Router,
    ) -> ::connectrpc::Router {
        router
            .route_view(
                SERVICE_SERVICE_NAME,
                "Put",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            __buffa::view::PutRequestView<'static>,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                PutRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.put(ctx, sreq).await?.encode::<PutResponse>(format)
                        }
                    })
                },
            )
            .with_spec(SERVICE_PUT_SPEC)
    }
}
/// Type-inference marker used by [`Router::add_service`](::connectrpc::Router::add_service).
#[doc(hidden)]
pub struct ServiceRegisterMarker;
impl<S: Service> ::connectrpc::ServiceRegister<ServiceRegisterMarker>
for ::std::sync::Arc<S> {
    fn register_service(self, router: ::connectrpc::Router) -> ::connectrpc::Router {
        <S as ServiceExt>::register(self, router)
    }
}
/// Monomorphic dispatcher for `Service`.
///
/// Unlike `.register(Router)` which type-erases each method into an `Arc<dyn ErasedHandler>` stored in a `HashMap`, this struct dispatches via a compile-time `match` on method name: no vtable, no hash lookup.
///
/// # Example
///
/// ```rust,ignore
/// use connectrpc::ConnectRpcService;
///
/// let server = ServiceServer::new(MyImpl);
/// let service = ConnectRpcService::new(server);
/// // hand `service` to axum/hyper as a fallback_service
/// ```
pub struct ServiceServer<T> {
    inner: ::std::sync::Arc<T>,
}
impl<T: Service> ServiceServer<T> {
    /// Wrap a service implementation in a monomorphic dispatcher.
    pub fn new(service: T) -> Self {
        Self {
            inner: ::std::sync::Arc::new(service),
        }
    }
    /// Wrap an already-`Arc`'d service implementation.
    pub fn from_arc(inner: ::std::sync::Arc<T>) -> Self {
        Self { inner }
    }
}
impl<T> Clone for ServiceServer<T> {
    fn clone(&self) -> Self {
        Self {
            inner: ::std::sync::Arc::clone(&self.inner),
        }
    }
}
impl<T: Service> ::connectrpc::Dispatcher for ServiceServer<T> {
    #[inline]
    fn lookup(
        &self,
        path: &str,
    ) -> Option<::connectrpc::dispatcher::codegen::MethodDescriptor> {
        let method = path.strip_prefix("log.ingest.v1.Service/")?;
        match method {
            "Put" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(SERVICE_PUT_SPEC),
                )
            }
            _ => None,
        }
    }
    fn call_unary(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::Payload,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
        let Some(method) = path.strip_prefix("log.ingest.v1.Service/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
        };
        let _ = (&ctx, &request, &format);
        match method {
            "Put" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        PutRequest,
                    >(request.encoded()?, format)?;
                    let req: __buffa::view::PutRequestView<'_> = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        PutRequest,
                    >::from_parts(&req, &body);
                    svc.put(ctx, req).await?.encode::<PutResponse>(format)
                })
            }
            _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
        }
    }
    fn call_server_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        request: ::buffa::bytes::Bytes,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
        let Some(method) = path.strip_prefix("log.ingest.v1.Service/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
        };
        let _ = (&ctx, &request, &format);
        match method {
            _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
        }
    }
    fn call_client_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        requests: ::connectrpc::dispatcher::codegen::RequestStream,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
        let Some(method) = path.strip_prefix("log.ingest.v1.Service/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
        };
        let _ = (&ctx, &requests, &format);
        match method {
            _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
        }
    }
    fn call_bidi_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        requests: ::connectrpc::dispatcher::codegen::RequestStream,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
        let Some(method) = path.strip_prefix("log.ingest.v1.Service/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
        };
        let _ = (&ctx, &requests, &format);
        match method {
            _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
        }
    }
}
/// Client for this service.
///
/// Generic over `T: ClientTransport`. For **gRPC** (HTTP/2), use
/// `Http2Connection` — it has honest `poll_ready` and composes with
/// `tower::balance` for multi-connection load balancing. For **Connect
/// over HTTP/1.1** (or unknown protocol), use `HttpClient`.
///
/// # Example (gRPC / HTTP/2)
///
/// ```rust,ignore
/// use connectrpc::client::{Http2Connection, ClientConfig};
/// use connectrpc::Protocol;
///
/// let uri: http::Uri = "http://localhost:8080".parse()?;
/// let conn = Http2Connection::connect_plaintext(uri.clone()).await?.shared(1024);
/// let config = ClientConfig::new(uri).with_protocol(Protocol::Grpc);
///
/// let client = ServiceClient::new(conn, config);
/// let response = client.put(request).await?;
/// ```
///
/// # Example (Connect / HTTP/1.1 or ALPN)
///
/// ```rust,ignore
/// use connectrpc::client::{HttpClient, ClientConfig};
///
/// let http = HttpClient::plaintext();  // cleartext http:// only
/// let config = ClientConfig::new("http://localhost:8080".parse()?);
///
/// let client = ServiceClient::new(http, config);
/// let response = client.put(request).await?;
/// ```
///
/// # Working with the response
///
/// Unary calls return [`UnaryResponse<OwnedView<FooView>>`](::connectrpc::client::UnaryResponse).
/// [`view()`](::connectrpc::client::UnaryResponse::view) borrows the response
/// message, so field access is zero-copy:
///
/// ```rust,ignore
/// let resp = client.put(request).await?;
/// let name: &str = resp.view().name;  // borrow into the response buffer
/// ```
///
/// If you need the owned struct (e.g. to store or pass by value), use
/// [`into_owned()`](::connectrpc::client::UnaryResponse::into_owned):
///
/// ```rust,ignore
/// let owned = client.put(request).await?.into_owned();
/// ```
///
/// [`into_view()`](::connectrpc::client::UnaryResponse::into_view) keeps the
/// zero-copy decoded body (an `OwnedView`) without copying; field access on it
/// goes through `.reborrow()`. Streaming responses yield one
/// [`StreamMessage`](::connectrpc::StreamMessage) per received message from
/// `.message().await` — read fields zero-copy through the generated accessor
/// methods (`msg.name()`) or `.view()`, or convert with `.to_owned_message()`.
#[derive(Clone)]
pub struct ServiceClient<T> {
    transport: T,
    config: ::connectrpc::client::ClientConfig,
}
impl<T> ServiceClient<T>
where
    T: ::connectrpc::client::ClientTransport,
    <T::ResponseBody as ::connectrpc::http_body::Body>::Error: ::std::fmt::Display,
{
    /// Create a new client with the given transport and configuration.
    pub fn new(transport: T, config: ::connectrpc::client::ClientConfig) -> Self {
        Self { transport, config }
    }
    /// Get the client configuration.
    pub fn config(&self) -> &::connectrpc::client::ClientConfig {
        &self.config
    }
    /// Get a mutable reference to the client configuration.
    pub fn config_mut(&mut self) -> &mut ::connectrpc::client::ClientConfig {
        &mut self.config
    }
    /// Call the Put RPC. Sends a request to /log.ingest.v1.Service/Put.
    pub async fn put(
        &self,
        request: PutRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<__buffa::view::PutResponseView<'static>>,
        >,
        ::connectrpc::ConnectError,
    > {
        self.put_with_options(request, ::connectrpc::client::CallOptions::default())
            .await
    }
    /// Call the Put RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn put_with_options(
        &self,
        request: PutRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<__buffa::view::PutResponseView<'static>>,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                SERVICE_PUT_SPEC.with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
}