sqlc_gen_sqlx/

plugin.codegen.rs

// @generated by buffa-codegen. DO NOT EDIT.
// source: plugin/codegen.proto

#[derive(Clone, PartialEq, Default)]
pub struct File {
    /// Field 1: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 2: `contents`
    pub contents: ::buffa::alloc::vec::Vec<u8>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for File {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("File")
            .field("name", &self.name)
            .field("contents", &self.contents)
            .finish()
    }
}
impl File {
    /// 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/plugin.File";
}
::buffa::impl_default_instance!(File);
impl ::buffa::MessageName for File {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "File";
    const FULL_NAME: &'static str = "plugin.File";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.File";
}
impl ::buffa::Message for File {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if !self.contents.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.contents) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if !self.contents.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.contents, 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.name, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.contents, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name.clear();
        self.contents.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for File {
    const PROTO_FQN: &'static str = "plugin.File";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Settings {
    /// Field 1: `version`
    pub version: ::buffa::alloc::string::String,
    /// Field 2: `engine`
    pub engine: ::buffa::alloc::string::String,
    /// Field 3: `schema`
    pub schema: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Field 4: `queries`
    pub queries: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Field 12: `codegen`
    pub codegen: ::buffa::MessageField<Codegen, ::buffa::Inline<Codegen>>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Settings {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Settings")
            .field("version", &self.version)
            .field("engine", &self.engine)
            .field("schema", &self.schema)
            .field("queries", &self.queries)
            .field("codegen", &self.codegen)
            .finish()
    }
}
impl Settings {
    /// 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/plugin.Settings";
}
::buffa::impl_default_instance!(Settings);
impl ::buffa::MessageName for Settings {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Settings";
    const FULL_NAME: &'static str = "plugin.Settings";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Settings";
}
impl ::buffa::Message for Settings {
    /// 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.version.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.version) as u64;
        }
        if !self.engine.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.engine) as u64;
        }
        for v in &self.schema {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.queries {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.codegen.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.codegen.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 _;
        if !self.version.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.version, buf);
        }
        if !self.engine.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.engine, buf);
        }
        for v in &self.schema {
            ::buffa::types::put_string_field(3u32, v, buf);
        }
        for v in &self.queries {
            ::buffa::types::put_string_field(4u32, v, buf);
        }
        if self.codegen.is_set() {
            ::buffa::types::put_len_delimited_header(
                12u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.codegen.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::types::merge_string(&mut self.version, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.engine, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.schema.push(__elem);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.queries.push(__elem);
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.codegen.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.version.clear();
        self.engine.clear();
        self.schema.clear();
        self.queries.clear();
        self.codegen = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Settings {
    const PROTO_FQN: &'static str = "plugin.Settings";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Codegen {
    /// Field 1: `out`
    pub out: ::buffa::alloc::string::String,
    /// Field 2: `plugin`
    pub plugin: ::buffa::alloc::string::String,
    /// Field 3: `options`
    pub options: ::buffa::alloc::vec::Vec<u8>,
    /// Field 4: `env`
    pub env: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Field 5: `process`
    pub process: ::buffa::MessageField<
        codegen::Process,
        ::buffa::Inline<codegen::Process>,
    >,
    /// Field 6: `wasm`
    pub wasm: ::buffa::MessageField<codegen::WASM, ::buffa::Inline<codegen::WASM>>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Codegen {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Codegen")
            .field("out", &self.out)
            .field("plugin", &self.plugin)
            .field("options", &self.options)
            .field("env", &self.env)
            .field("process", &self.process)
            .field("wasm", &self.wasm)
            .finish()
    }
}
impl Codegen {
    /// 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/plugin.Codegen";
}
::buffa::impl_default_instance!(Codegen);
impl ::buffa::MessageName for Codegen {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Codegen";
    const FULL_NAME: &'static str = "plugin.Codegen";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Codegen";
}
impl ::buffa::Message for Codegen {
    /// 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.out.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.out) as u64;
        }
        if !self.plugin.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.plugin) as u64;
        }
        if !self.options.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.options) as u64;
        }
        for v in &self.env {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.process.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.process.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.wasm.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.wasm.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 _;
        if !self.out.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.out, buf);
        }
        if !self.plugin.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.plugin, buf);
        }
        if !self.options.is_empty() {
            ::buffa::types::put_shared_bytes_field(3u32, &self.options, buf);
        }
        for v in &self.env {
            ::buffa::types::put_string_field(4u32, v, buf);
        }
        if self.process.is_set() {
            ::buffa::types::put_len_delimited_header(
                5u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.process.write_to(__cache, buf);
        }
        if self.wasm.is_set() {
            ::buffa::types::put_len_delimited_header(
                6u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.wasm.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::types::merge_string(&mut self.out, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.plugin, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.options, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.env.push(__elem);
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.process.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.wasm.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.out.clear();
        self.plugin.clear();
        self.options.clear();
        self.env.clear();
        self.process = ::buffa::MessageField::none();
        self.wasm = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Codegen {
    const PROTO_FQN: &'static str = "plugin.Codegen";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
pub mod codegen {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, PartialEq, Default)]
    pub struct Process {
        /// Field 1: `cmd`
        pub cmd: ::buffa::alloc::string::String,
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for Process {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("Process").field("cmd", &self.cmd).finish()
        }
    }
    impl Process {
        /// 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/plugin.Codegen.Process";
    }
    ::buffa::impl_default_instance!(Process);
    impl ::buffa::MessageName for Process {
        const PACKAGE: &'static str = "plugin";
        const NAME: &'static str = "Codegen.Process";
        const FULL_NAME: &'static str = "plugin.Codegen.Process";
        const TYPE_URL: &'static str = "type.googleapis.com/plugin.Codegen.Process";
    }
    impl ::buffa::Message for Process {
        /// 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.cmd.is_empty() {
                size += 1u64 + ::buffa::types::string_encoded_len(&self.cmd) 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.cmd.is_empty() {
                ::buffa::types::put_string_field(1u32, &self.cmd, 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.cmd, buf)?;
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.cmd.clear();
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for Process {
        const PROTO_FQN: &'static str = "plugin.Codegen.Process";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[derive(Clone, PartialEq, Default)]
    pub struct WASM {
        /// Field 1: `url`
        pub url: ::buffa::alloc::string::String,
        /// Field 2: `sha256`
        pub sha256: ::buffa::alloc::string::String,
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for WASM {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("WASM")
                .field("url", &self.url)
                .field("sha256", &self.sha256)
                .finish()
        }
    }
    impl WASM {
        /// 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/plugin.Codegen.WASM";
    }
    ::buffa::impl_default_instance!(WASM);
    impl ::buffa::MessageName for WASM {
        const PACKAGE: &'static str = "plugin";
        const NAME: &'static str = "Codegen.WASM";
        const FULL_NAME: &'static str = "plugin.Codegen.WASM";
        const TYPE_URL: &'static str = "type.googleapis.com/plugin.Codegen.WASM";
    }
    impl ::buffa::Message for WASM {
        /// 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.url.is_empty() {
                size += 1u64 + ::buffa::types::string_encoded_len(&self.url) as u64;
            }
            if !self.sha256.is_empty() {
                size += 1u64 + ::buffa::types::string_encoded_len(&self.sha256) 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.url.is_empty() {
                ::buffa::types::put_string_field(1u32, &self.url, buf);
            }
            if !self.sha256.is_empty() {
                ::buffa::types::put_string_field(2u32, &self.sha256, 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.url, buf)?;
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(&mut self.sha256, buf)?;
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.url.clear();
            self.sha256.clear();
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for WASM {
        const PROTO_FQN: &'static str = "plugin.Codegen.WASM";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[doc(inline)]
    pub use super::__buffa::view::codegen::ProcessView;
    #[doc(inline)]
    pub use super::__buffa::view::codegen::ProcessOwnedView;
    #[doc(inline)]
    pub use super::__buffa::view::codegen::WASMView;
    #[doc(inline)]
    pub use super::__buffa::view::codegen::WASMOwnedView;
}
#[derive(Clone, PartialEq, Default)]
pub struct Catalog {
    /// Field 1: `comment`
    pub comment: ::buffa::alloc::string::String,
    /// Field 2: `default_schema`
    pub default_schema: ::buffa::alloc::string::String,
    /// Field 3: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 4: `schemas`
    pub schemas: ::buffa::alloc::vec::Vec<Schema>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Catalog {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Catalog")
            .field("comment", &self.comment)
            .field("default_schema", &self.default_schema)
            .field("name", &self.name)
            .field("schemas", &self.schemas)
            .finish()
    }
}
impl Catalog {
    /// 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/plugin.Catalog";
}
::buffa::impl_default_instance!(Catalog);
impl ::buffa::MessageName for Catalog {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Catalog";
    const FULL_NAME: &'static str = "plugin.Catalog";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Catalog";
}
impl ::buffa::Message for Catalog {
    /// 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.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) as u64;
        }
        if !self.default_schema.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.default_schema) as u64;
        }
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        for v in &self.schemas {
            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 _;
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.comment, buf);
        }
        if !self.default_schema.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.default_schema, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.name, buf);
        }
        for v in &self.schemas {
            ::buffa::types::put_len_delimited_header(
                4u32,
                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,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.default_schema, 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::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.schemas.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.comment.clear();
        self.default_schema.clear();
        self.name.clear();
        self.schemas.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Catalog {
    const PROTO_FQN: &'static str = "plugin.Catalog";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Schema {
    /// Field 1: `comment`
    pub comment: ::buffa::alloc::string::String,
    /// Field 2: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 3: `tables`
    pub tables: ::buffa::alloc::vec::Vec<Table>,
    /// Field 4: `enums`
    pub enums: ::buffa::alloc::vec::Vec<Enum>,
    /// Field 5: `composite_types`
    pub composite_types: ::buffa::alloc::vec::Vec<CompositeType>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Schema {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Schema")
            .field("comment", &self.comment)
            .field("name", &self.name)
            .field("tables", &self.tables)
            .field("enums", &self.enums)
            .field("composite_types", &self.composite_types)
            .finish()
    }
}
impl Schema {
    /// 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/plugin.Schema";
}
::buffa::impl_default_instance!(Schema);
impl ::buffa::MessageName for Schema {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Schema";
    const FULL_NAME: &'static str = "plugin.Schema";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Schema";
}
impl ::buffa::Message for Schema {
    /// 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.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) as u64;
        }
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        for v in &self.tables {
            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;
        }
        for v in &self.enums {
            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;
        }
        for v in &self.composite_types {
            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 _;
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.comment, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.name, buf);
        }
        for v in &self.tables {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.enums {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.composite_types {
            ::buffa::types::put_len_delimited_header(
                5u32,
                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,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            3u32 => {
                ::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.tables.push(elem);
            }
            4u32 => {
                ::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.enums.push(elem);
            }
            5u32 => {
                ::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.composite_types.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.comment.clear();
        self.name.clear();
        self.tables.clear();
        self.enums.clear();
        self.composite_types.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Schema {
    const PROTO_FQN: &'static str = "plugin.Schema";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct CompositeType {
    /// Field 1: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 2: `comment`
    pub comment: ::buffa::alloc::string::String,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CompositeType {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CompositeType")
            .field("name", &self.name)
            .field("comment", &self.comment)
            .finish()
    }
}
impl CompositeType {
    /// 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/plugin.CompositeType";
}
::buffa::impl_default_instance!(CompositeType);
impl ::buffa::MessageName for CompositeType {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "CompositeType";
    const FULL_NAME: &'static str = "plugin.CompositeType";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.CompositeType";
}
impl ::buffa::Message for CompositeType {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if !self.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.comment, 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.name, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name.clear();
        self.comment.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for CompositeType {
    const PROTO_FQN: &'static str = "plugin.CompositeType";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Enum {
    /// Field 1: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 2: `vals`
    pub vals: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Field 3: `comment`
    pub comment: ::buffa::alloc::string::String,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Enum {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Enum")
            .field("name", &self.name)
            .field("vals", &self.vals)
            .field("comment", &self.comment)
            .finish()
    }
}
impl Enum {
    /// 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/plugin.Enum";
}
::buffa::impl_default_instance!(Enum);
impl ::buffa::MessageName for Enum {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Enum";
    const FULL_NAME: &'static str = "plugin.Enum";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Enum";
}
impl ::buffa::Message for Enum {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        for v in &self.vals {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if !self.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        for v in &self.vals {
            ::buffa::types::put_string_field(2u32, v, buf);
        }
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.comment, 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.name, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.vals.push(__elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name.clear();
        self.vals.clear();
        self.comment.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Enum {
    const PROTO_FQN: &'static str = "plugin.Enum";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Table {
    /// Field 1: `rel`
    pub rel: ::buffa::MessageField<Identifier, ::buffa::Inline<Identifier>>,
    /// Field 2: `columns`
    pub columns: ::buffa::alloc::vec::Vec<Column>,
    /// Field 3: `comment`
    pub comment: ::buffa::alloc::string::String,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Table {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Table")
            .field("rel", &self.rel)
            .field("columns", &self.columns)
            .field("comment", &self.comment)
            .finish()
    }
}
impl Table {
    /// 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/plugin.Table";
}
::buffa::impl_default_instance!(Table);
impl ::buffa::MessageName for Table {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Table";
    const FULL_NAME: &'static str = "plugin.Table";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Table";
}
impl ::buffa::Message for Table {
    /// 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.rel.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.rel.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.columns {
            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;
        }
        if !self.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) 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.rel.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.rel.write_to(__cache, buf);
        }
        for v in &self.columns {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.comment, 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.rel.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            2u32 => {
                ::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.columns.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.rel = ::buffa::MessageField::none();
        self.columns.clear();
        self.comment.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Table {
    const PROTO_FQN: &'static str = "plugin.Table";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Identifier {
    /// Field 1: `catalog`
    pub catalog: ::buffa::alloc::string::String,
    /// Field 2: `schema`
    pub schema: ::buffa::alloc::string::String,
    /// Field 3: `name`
    pub name: ::buffa::alloc::string::String,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Identifier {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Identifier")
            .field("catalog", &self.catalog)
            .field("schema", &self.schema)
            .field("name", &self.name)
            .finish()
    }
}
impl Identifier {
    /// 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/plugin.Identifier";
}
::buffa::impl_default_instance!(Identifier);
impl ::buffa::MessageName for Identifier {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Identifier";
    const FULL_NAME: &'static str = "plugin.Identifier";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Identifier";
}
impl ::buffa::Message for Identifier {
    /// 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.catalog.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.catalog) as u64;
        }
        if !self.schema.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.schema) as u64;
        }
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) 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.catalog.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.catalog, buf);
        }
        if !self.schema.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.schema, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.name, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.catalog, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.schema, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.catalog.clear();
        self.schema.clear();
        self.name.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Identifier {
    const PROTO_FQN: &'static str = "plugin.Identifier";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Column {
    /// Field 1: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 3: `not_null`
    pub not_null: bool,
    /// Field 4: `is_array`
    pub is_array: bool,
    /// Field 5: `comment`
    pub comment: ::buffa::alloc::string::String,
    /// Field 6: `length`
    pub length: i32,
    /// Field 7: `is_named_param`
    pub is_named_param: bool,
    /// Field 8: `is_func_call`
    pub is_func_call: bool,
    /// XXX: Figure out what PostgreSQL calls `foo.id`
    ///
    /// Field 9: `scope`
    pub scope: ::buffa::alloc::string::String,
    /// Field 10: `table`
    pub table: ::buffa::MessageField<Identifier, ::buffa::Inline<Identifier>>,
    /// Field 11: `table_alias`
    pub table_alias: ::buffa::alloc::string::String,
    /// Field 12: `type`
    pub r#type: ::buffa::MessageField<Identifier, ::buffa::Inline<Identifier>>,
    /// Field 13: `is_sqlc_slice`
    pub is_sqlc_slice: bool,
    /// Field 14: `embed_table`
    pub embed_table: ::buffa::MessageField<Identifier, ::buffa::Inline<Identifier>>,
    /// Field 15: `original_name`
    pub original_name: ::buffa::alloc::string::String,
    /// Field 16: `unsigned`
    pub unsigned: bool,
    /// Field 17: `array_dims`
    pub array_dims: i32,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Column {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Column")
            .field("name", &self.name)
            .field("not_null", &self.not_null)
            .field("is_array", &self.is_array)
            .field("comment", &self.comment)
            .field("length", &self.length)
            .field("is_named_param", &self.is_named_param)
            .field("is_func_call", &self.is_func_call)
            .field("scope", &self.scope)
            .field("table", &self.table)
            .field("table_alias", &self.table_alias)
            .field("type", &self.r#type)
            .field("is_sqlc_slice", &self.is_sqlc_slice)
            .field("embed_table", &self.embed_table)
            .field("original_name", &self.original_name)
            .field("unsigned", &self.unsigned)
            .field("array_dims", &self.array_dims)
            .finish()
    }
}
impl Column {
    /// 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/plugin.Column";
}
::buffa::impl_default_instance!(Column);
impl ::buffa::MessageName for Column {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Column";
    const FULL_NAME: &'static str = "plugin.Column";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Column";
}
impl ::buffa::Message for Column {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if self.not_null {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.is_array {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.comment.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.comment) as u64;
        }
        if self.length != 0i32 {
            size += 1u64 + ::buffa::types::int32_encoded_len(self.length) as u64;
        }
        if self.is_named_param {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.is_func_call {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.scope.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.scope) as u64;
        }
        if self.table.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.table.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if !self.table_alias.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.table_alias) as u64;
        }
        if self.r#type.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.r#type.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.is_sqlc_slice {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.embed_table.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.embed_table.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if !self.original_name.is_empty() {
            size
                += 1u64 + ::buffa::types::string_encoded_len(&self.original_name) as u64;
        }
        if self.unsigned {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.array_dims != 0i32 {
            size += 2u64 + ::buffa::types::int32_encoded_len(self.array_dims) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if self.not_null {
            ::buffa::types::put_bool_field(3u32, self.not_null, buf);
        }
        if self.is_array {
            ::buffa::types::put_bool_field(4u32, self.is_array, buf);
        }
        if !self.comment.is_empty() {
            ::buffa::types::put_string_field(5u32, &self.comment, buf);
        }
        if self.length != 0i32 {
            ::buffa::types::put_int32_field(6u32, self.length, buf);
        }
        if self.is_named_param {
            ::buffa::types::put_bool_field(7u32, self.is_named_param, buf);
        }
        if self.is_func_call {
            ::buffa::types::put_bool_field(8u32, self.is_func_call, buf);
        }
        if !self.scope.is_empty() {
            ::buffa::types::put_string_field(9u32, &self.scope, buf);
        }
        if self.table.is_set() {
            ::buffa::types::put_len_delimited_header(
                10u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.table.write_to(__cache, buf);
        }
        if !self.table_alias.is_empty() {
            ::buffa::types::put_string_field(11u32, &self.table_alias, buf);
        }
        if self.r#type.is_set() {
            ::buffa::types::put_len_delimited_header(
                12u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.r#type.write_to(__cache, buf);
        }
        if self.is_sqlc_slice {
            ::buffa::types::put_bool_field(13u32, self.is_sqlc_slice, buf);
        }
        if self.embed_table.is_set() {
            ::buffa::types::put_len_delimited_header(
                14u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.embed_table.write_to(__cache, buf);
        }
        if !self.original_name.is_empty() {
            ::buffa::types::put_string_field(15u32, &self.original_name, buf);
        }
        if self.unsigned {
            ::buffa::types::put_bool_field(16u32, self.unsigned, buf);
        }
        if self.array_dims != 0i32 {
            ::buffa::types::put_int32_field(17u32, self.array_dims, 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.name, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.not_null = ::buffa::types::decode_bool(buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_array = ::buffa::types::decode_bool(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.comment, buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.length = ::buffa::types::decode_int32(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_named_param = ::buffa::types::decode_bool(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_func_call = ::buffa::types::decode_bool(buf)?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.scope, buf)?;
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.table.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.table_alias, buf)?;
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.r#type.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            13u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.is_sqlc_slice = ::buffa::types::decode_bool(buf)?;
            }
            14u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.embed_table.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.original_name, buf)?;
            }
            16u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.unsigned = ::buffa::types::decode_bool(buf)?;
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.array_dims = ::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.name.clear();
        self.not_null = false;
        self.is_array = false;
        self.comment.clear();
        self.length = 0i32;
        self.is_named_param = false;
        self.is_func_call = false;
        self.scope.clear();
        self.table = ::buffa::MessageField::none();
        self.table_alias.clear();
        self.r#type = ::buffa::MessageField::none();
        self.is_sqlc_slice = false;
        self.embed_table = ::buffa::MessageField::none();
        self.original_name.clear();
        self.unsigned = false;
        self.array_dims = 0i32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Column {
    const PROTO_FQN: &'static str = "plugin.Column";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Query {
    /// Field 1: `text`
    pub text: ::buffa::alloc::string::String,
    /// Field 2: `name`
    pub name: ::buffa::alloc::string::String,
    /// Field 3: `cmd`
    pub cmd: ::buffa::alloc::string::String,
    /// Field 4: `columns`
    pub columns: ::buffa::alloc::vec::Vec<Column>,
    /// Field 5: `params`
    pub params: ::buffa::alloc::vec::Vec<Parameter>,
    /// Field 6: `comments`
    pub comments: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Field 7: `filename`
    pub filename: ::buffa::alloc::string::String,
    /// Field 8: `insert_into_table`
    pub insert_into_table: ::buffa::MessageField<
        Identifier,
        ::buffa::Inline<Identifier>,
    >,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Query {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Query")
            .field("text", &self.text)
            .field("name", &self.name)
            .field("cmd", &self.cmd)
            .field("columns", &self.columns)
            .field("params", &self.params)
            .field("comments", &self.comments)
            .field("filename", &self.filename)
            .field("insert_into_table", &self.insert_into_table)
            .finish()
    }
}
impl Query {
    /// 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/plugin.Query";
}
::buffa::impl_default_instance!(Query);
impl ::buffa::MessageName for Query {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Query";
    const FULL_NAME: &'static str = "plugin.Query";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Query";
}
impl ::buffa::Message for Query {
    /// 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.text.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.text) as u64;
        }
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if !self.cmd.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.cmd) as u64;
        }
        for v in &self.columns {
            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;
        }
        for v in &self.params {
            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;
        }
        for v in &self.comments {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if !self.filename.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.filename) as u64;
        }
        if self.insert_into_table.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.insert_into_table.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 _;
        if !self.text.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.text, buf);
        }
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.name, buf);
        }
        if !self.cmd.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.cmd, buf);
        }
        for v in &self.columns {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.params {
            ::buffa::types::put_len_delimited_header(
                5u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.comments {
            ::buffa::types::put_string_field(6u32, v, buf);
        }
        if !self.filename.is_empty() {
            ::buffa::types::put_string_field(7u32, &self.filename, buf);
        }
        if self.insert_into_table.is_set() {
            ::buffa::types::put_len_delimited_header(
                8u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.insert_into_table.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::types::merge_string(&mut self.text, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.cmd, buf)?;
            }
            4u32 => {
                ::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.columns.push(elem);
            }
            5u32 => {
                ::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.params.push(elem);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.comments.push(__elem);
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.filename, buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.insert_into_table.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.text.clear();
        self.name.clear();
        self.cmd.clear();
        self.columns.clear();
        self.params.clear();
        self.comments.clear();
        self.filename.clear();
        self.insert_into_table = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Query {
    const PROTO_FQN: &'static str = "plugin.Query";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct Parameter {
    /// Field 1: `number`
    pub number: i32,
    /// Field 2: `column`
    pub column: ::buffa::MessageField<Column, ::buffa::Inline<Column>>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for Parameter {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("Parameter")
            .field("number", &self.number)
            .field("column", &self.column)
            .finish()
    }
}
impl Parameter {
    /// 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/plugin.Parameter";
}
::buffa::impl_default_instance!(Parameter);
impl ::buffa::MessageName for Parameter {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "Parameter";
    const FULL_NAME: &'static str = "plugin.Parameter";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.Parameter";
}
impl ::buffa::Message for Parameter {
    /// 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.number != 0i32 {
            size += 1u64 + ::buffa::types::int32_encoded_len(self.number) as u64;
        }
        if self.column.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.column.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 _;
        if self.number != 0i32 {
            ::buffa::types::put_int32_field(1u32, self.number, buf);
        }
        if self.column.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.column.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.number = ::buffa::types::decode_int32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.column.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.number = 0i32;
        self.column = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for Parameter {
    const PROTO_FQN: &'static str = "plugin.Parameter";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct GenerateRequest {
    /// Field 1: `settings`
    pub settings: ::buffa::MessageField<Settings, ::buffa::Inline<Settings>>,
    /// Field 2: `catalog`
    pub catalog: ::buffa::MessageField<Catalog, ::buffa::Inline<Catalog>>,
    /// Field 3: `queries`
    pub queries: ::buffa::alloc::vec::Vec<Query>,
    /// Field 4: `sqlc_version`
    pub sqlc_version: ::buffa::alloc::string::String,
    /// Field 5: `plugin_options`
    pub plugin_options: ::buffa::alloc::vec::Vec<u8>,
    /// Field 6: `global_options`
    pub global_options: ::buffa::alloc::vec::Vec<u8>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GenerateRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GenerateRequest")
            .field("settings", &self.settings)
            .field("catalog", &self.catalog)
            .field("queries", &self.queries)
            .field("sqlc_version", &self.sqlc_version)
            .field("plugin_options", &self.plugin_options)
            .field("global_options", &self.global_options)
            .finish()
    }
}
impl GenerateRequest {
    /// 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/plugin.GenerateRequest";
}
::buffa::impl_default_instance!(GenerateRequest);
impl ::buffa::MessageName for GenerateRequest {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "GenerateRequest";
    const FULL_NAME: &'static str = "plugin.GenerateRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.GenerateRequest";
}
impl ::buffa::Message for GenerateRequest {
    /// 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.settings.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.settings.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.catalog.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.catalog.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.queries {
            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;
        }
        if !self.sqlc_version.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.sqlc_version) as u64;
        }
        if !self.plugin_options.is_empty() {
            size
                += 1u64 + ::buffa::types::bytes_encoded_len(&self.plugin_options) as u64;
        }
        if !self.global_options.is_empty() {
            size
                += 1u64 + ::buffa::types::bytes_encoded_len(&self.global_options) 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.settings.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.settings.write_to(__cache, buf);
        }
        if self.catalog.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.catalog.write_to(__cache, buf);
        }
        for v in &self.queries {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if !self.sqlc_version.is_empty() {
            ::buffa::types::put_string_field(4u32, &self.sqlc_version, buf);
        }
        if !self.plugin_options.is_empty() {
            ::buffa::types::put_shared_bytes_field(5u32, &self.plugin_options, buf);
        }
        if !self.global_options.is_empty() {
            ::buffa::types::put_shared_bytes_field(6u32, &self.global_options, 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.settings.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.catalog.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::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.queries.push(elem);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.sqlc_version, buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.plugin_options, buf)?;
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.global_options, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.settings = ::buffa::MessageField::none();
        self.catalog = ::buffa::MessageField::none();
        self.queries.clear();
        self.sqlc_version.clear();
        self.plugin_options.clear();
        self.global_options.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GenerateRequest {
    const PROTO_FQN: &'static str = "plugin.GenerateRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[derive(Clone, PartialEq, Default)]
pub struct GenerateResponse {
    /// Field 1: `files`
    pub files: ::buffa::alloc::vec::Vec<File>,
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GenerateResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GenerateResponse").field("files", &self.files).finish()
    }
}
impl GenerateResponse {
    /// 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/plugin.GenerateResponse";
}
::buffa::impl_default_instance!(GenerateResponse);
impl ::buffa::MessageName for GenerateResponse {
    const PACKAGE: &'static str = "plugin";
    const NAME: &'static str = "GenerateResponse";
    const FULL_NAME: &'static str = "plugin.GenerateResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/plugin.GenerateResponse";
}
impl ::buffa::Message for GenerateResponse {
    /// 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.files {
            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.files {
            ::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.files.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.files.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GenerateResponse {
    const PROTO_FQN: &'static str = "plugin.GenerateResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}