{%- for target_f in m.fields %}

{%- let maybe_gp %}
{%- if target_f.is_repeated %}
    {%- let maybe_gp = "<ScalarType, RepeatedType>" %}
{%- else %}
    {%- let maybe_gp = "<ScalarType>" %}
{%- endif %}

pub struct {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
{
    pub {{ target_f.ident }}: {{ target_f.single_field_type }},
}

impl{{ maybe_gp }} ::puroro::Message<super::{{ m.simple_ident }}>
for {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
{}

impl{{ maybe_gp }} super::_puroro_traits::{{ m.trait_ident }}
for {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
{
    {%- for f in m.fields %}
    {%- if f.number == target_f.number %}
    {%- call single_field_trait_impl_field(f) %}
    {%- else %} {#- if f.number == target_f.number #}

    {%- if f.is_message %}
    type {{ f.ident_camel_unesc }}MessageType<'this> where Self: 'this = ();
    {%- endif %}

    {%- if f.is_repeated %}
    type {{ f.ident_camel_unesc }}RepeatedType<'this> where Self: 'this = ::puroro::internal::impls::empty::EmptyRepeatedField<{{ f.trait_scalar_getter_type }}>;
    fn {{ f.ident }}<'this>(&'this self) -> Self::{{ f.ident_camel_unesc }}RepeatedType<'this> {
        ::puroro::internal::impls::empty::EmptyRepeatedField::new()
    }
    {%- endif %}

    {%- endif %} {#- if f.number == target_f.number #}
    {%- endfor %} {#- for f in m.fields #}

    {%- for oneof in m.oneofs %}
    fn {{ oneof.field_ident }}(&self) ->
        ::std::option::Option<
            super::_puroro_nested::{{ m.submodule_ident }}::_puroro_oneofs::
                {{ oneof.enum_ident }}{{ oneof.enum_maybe_gp_self }}
        >
    {
        {%- if target_f.oneof_index == oneof.index %}
        use super::_puroro_nested::{{ m.submodule_ident }}::_puroro_oneofs::{{ oneof.enum_ident }} as E;
        ::std::option::Option::Some(
            E::{{ target_f.oneof_enum_value_ident }}(
                {%- if target_f.is_message %}
                &self.{{ target_f.ident }}
                {%- endif %} {#- if target_f.is_message #}
                {%- if target_f.is_string || target_f.is_bytes %}
                self.{{ target_f.ident }}.as_ref()
                {%- endif %} {#- if target_f.is_string || target_f.is_bytes #}
                {%- if target_f.is_numerical %}
                ::std::convert::Into::into(
                    ::std::clone::Clone::clone(&self.{{ target_f.ident }})
                )
                {%- endif %} {#- if target_f.is_numerical #}
            )
        )
        {%- else %}
        ::std::option::Option::None
        {%- endif %}
    }
    {%- endfor %}
}


impl{{ maybe_gp }} ::puroro::internal::se::SerMessageToIoWrite
for {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
    Self: super::_puroro_traits::{{ m.ident }}Trait,
{%- if target_f.is_message %}
    for<'a> <Self as super::_puroro_traits::{{ m.ident }}Trait>::{{ target_f.ident_camel_unesc }}MessageType<'a> :
        ::puroro::internal::se::SerMessageToIoWrite,
{%- endif %}
{
    fn ser<W>(&self, out: &mut W) -> ::puroro::Result<()>
    where
        W: ::std::io::Write,
    {
        ::puroro::internal::se::SerFieldToIoWrite::<
            {{ target_f.trait_label_and_type_tags }}
        >::ser_field(
            {%- if target_f.is_repeated %}
            <Self as super::_puroro_traits::{{ m.ident }}Trait>::{{ target_f.ident }}(self),
            {%- else %}
            <Self as super::_puroro_traits::{{ m.ident }}Trait>::{{ target_f.ident_unesc }}_opt(self),
            {%- endif %}
            {{ target_f.number }},
            out
        )?;
        ::std::result::Result::Ok(())
    }
}

impl{{ maybe_gp }} ::std::convert::From<{{ target_f.single_field_type }}>
for {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
{
    fn from(value: {{ target_f.single_field_type }}) -> Self {
        Self {
            {{ target_f.ident }}: value,
        }
    }
}

impl{{ maybe_gp }} ::std::clone::Clone
for {{ m.single_field_ident }}{{ target_f.number }}{{ maybe_gp }}
{%- call single_field_bound(target_f) %}
    {{ target_f.single_field_type }}: ::std::clone::Clone,
{
    fn clone(&self) -> Self {
        Self {
            {{ target_f.ident }}: ::std::clone::Clone::clone(&self.{{ target_f.ident }}),
        }
    }
}

{%- endfor %}