rydantic_derive/

lib.rs

use proc_macro::TokenStream;
use proc_macro2::TokenStream as Tokens;
use quote::format_ident;
use syn::{
    parse_macro_input, parse_quote, spanned::Spanned, Data, DeriveInput, Expr, Fields, Ident,
    Member, Type,
};
mod attrs;
#[cfg(feature = "capnp")]
mod auto_protocol;
mod native;
mod sql_model;

// Generated locals must not shadow callback paths (or default expressions) from
// the input. Mixed-site hygiene applies only to tokens written by the macro;
// interpolated user tokens retain their original spans and name resolution.
// Keep this after the module declarations: it scopes the policy to Model's
// expansion here, rather than changing the other derives' quote invocations.
macro_rules! quote {
    ($($tokens:tt)*) => {
        ::quote::quote_spanned!(::proc_macro2::Span::mixed_site()=> $($tokens)*)
    };
}

fn field_ident(index: usize) -> Ident {
    format_ident!(
        "__rydantic_field_{index}",
        span = proc_macro2::Span::mixed_site()
    )
}

/// Derive SQL schema metadata, SQLx row decoding and validated CRUD operations.
#[proc_macro_derive(SqlModel, attributes(sql, model))]
pub fn derive_sql_model(input: TokenStream) -> TokenStream {
    sql_model::expand(parse_macro_input!(input as DeriveInput))
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

/// Derive a complete Cap'n Proto protocol and its bindings from an inline model module.
/// Every model must explicitly derive `Model` (an imported alias also works).
/// This attribute does not insert or resolve derive macros.
#[cfg(feature = "capnp")]
#[proc_macro_attribute]
pub fn capnp_models(args: TokenStream, input: TokenStream) -> TokenStream {
    auto_protocol::prepare(args.into(), input.into(), false)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

// The runtime re-export selects its own helper path explicitly. A consumer may
// also declare an inactive or differently versioned direct proc-macro dependency.
#[doc(hidden)]
#[cfg(feature = "capnp")]
#[proc_macro_attribute]
pub fn __rydantic_capnp_models_runtime(args: TokenStream, input: TokenStream) -> TokenStream {
    auto_protocol::prepare(args.into(), input.into(), true)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

// Internal compiler-driven cfg normalization for `capnp_models`.
#[doc(hidden)]
#[cfg(feature = "capnp")]
#[proc_macro_derive(__RydanticCapnpConfigured, attributes(__rydantic_capnp_options))]
pub fn capnp_configured(input: TokenStream) -> TokenStream {
    auto_protocol::configured(input.into())
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

#[doc(hidden)]
#[cfg(feature = "capnp")]
#[proc_macro_attribute]
pub fn __rydantic_capnp_discard(_: TokenStream, _: TokenStream) -> TokenStream {
    TokenStream::new()
}

#[proc_macro_derive(Model, attributes(model))]
pub fn derive_model(input: TokenStream) -> TokenStream {
    expand(parse_macro_input!(input as DeriveInput))
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

struct Field {
    ident: Ident,
    member: Member,
    ty: Type,
    attr: attrs::Field,
    input: String,
    output: String,
    doc: ::core::option::Option<String>,
}
#[derive(Clone, Copy, PartialEq)]
enum Shape {
    Named,
    Tuple,
    Unit,
}
fn shape(fields: &Fields) -> Shape {
    match fields {
        Fields::Named(_) => Shape::Named,
        Fields::Unnamed(_) => Shape::Tuple,
        Fields::Unit => Shape::Unit,
    }
}
fn fields(
    source: &Fields,
    tag: ::core::option::Option<&str>,
    container: &attrs::Container,
) -> syn::Result<Vec<Field>> {
    let mut inputs = std::collections::HashSet::new();
    let mut outputs = std::collections::HashSet::new();
    let mut extras = 0;
    let result=source.iter().enumerate().map(|(i,field)|{
        let ident=field.ident.clone().unwrap_or_else(||format_ident!("__tuple_{i}"));
        let member=field.ident.clone().map(Member::Named).unwrap_or_else(||Member::Unnamed(i.into()));
        let attr=attrs::field(&field.attrs)?;
        if attr.extra{extras+=1;}
        if matches!(source,Fields::Unnamed(_)) && (attr.flatten||attr.extra||attr.rename.is_some()||attr.validation_alias.is_some()||attr.serialization_alias.is_some()||attr.exclude||attr.has_default()){
            return Err(syn::Error::new(field.span(),"tuple fields support validation and transformations; names, flatten, extra, exclude and defaults require named fields"));
        }
        if (attr.flatten||attr.extra)&&(attr.rename.is_some()||attr.validation_alias.is_some()||attr.serialization_alias.is_some()||attr.before.is_some()||attr.coerce||attr.has_rules()){
            return Err(syn::Error::new(field.span(),"flatten and extra fields use their inner model's names, transformations and constraints"));
        }
        let base=attr.rename.clone().unwrap_or_else(||if field.ident.is_some(){ident.to_string().trim_start_matches("r#").to_owned()}else{i.to_string()});
        let input=attr.validation_alias.clone().unwrap_or_else(||base.clone());let output=attr.serialization_alias.clone().unwrap_or(base);
        if !attr.flatten&&!attr.extra{
            if !inputs.insert(input.clone())||tag==Some(input.as_str()){return Err(syn::Error::new(ident.span(),"duplicate input field name or collision with enum tag"));}
            if !attr.exclude&&(!outputs.insert(output.clone())||tag==Some(output.as_str())){return Err(syn::Error::new(ident.span(),"duplicate output field name or collision with enum tag"));}
        }
        let doc=attr.description.clone().or_else(||{
            let text=field.attrs.iter().filter_map(|attr|{if !attr.path().is_ident("doc"){return None;}let syn::Meta::NameValue(v)=&attr.meta else{return None;};let Expr::Lit(v)=&v.value else{return None;};let syn::Lit::Str(v)=&v.lit else{return None;};Some(v.value().trim().to_owned())}).collect::<Vec<_>>();(!text.is_empty()).then(||text.join("\n"))
        });
        Ok(Field{ident,member,ty:field.ty.clone(),attr,input,output,doc})
    }).collect::<syn::Result<Vec<_>>>()?;
    if extras > 1 {
        return Err(syn::Error::new(
            source.span(),
            "a model may have only one extra field",
        ));
    }
    if container.allow_extra && extras != 1 {
        return Err(syn::Error::new(
            source.span(),
            "extra = \"allow\" requires one #[model(extra)] map field",
        ));
    }
    if !container.allow_extra && extras != 0 {
        return Err(syn::Error::new(
            source.span(),
            "#[model(extra)] requires #[model(extra = \"allow\")]",
        ));
    }
    Ok(result)
}
fn option<T: quote::ToTokens>(value: &::core::option::Option<T>) -> Tokens {
    match value {
        Some(v) => quote!(Some(#v)),
        None => quote!(None),
    }
}
fn rules(field: &Field, rd: &Tokens) -> Tokens {
    let a = &field.attr;
    let trim = a.trim;
    let lower = a.lowercase;
    let upper = a.uppercase;
    let email = a.email;
    let min = option(&a.min_length);
    let max = option(&a.max_length);
    let number = |v: &::core::option::Option<String>| match v {
        Some(v) => quote!(Some(#rd::__private::number(#v))),
        None => quote!(None),
    };
    let ge = number(&a.ge);
    let gt = number(&a.gt);
    let le = number(&a.le);
    let lt = number(&a.lt);
    let pattern = match &a.pattern {
        Some(v) => {
            quote!(Some(#rd::__private::regex::Regex::new(#v).expect("regex checked by Model derive")))
        }
        None => quote!(None),
    };
    quote!({static RULES: ::std::sync::OnceLock<#rd::rules::Rules>=::std::sync::OnceLock::new();RULES.get_or_init(||#rd::rules::Rules{trim:#trim,lowercase:#lower,uppercase:#upper,min_length:#min,max_length:#max,ge:#ge,gt:#gt,le:#le,lt:#lt,pattern:#pattern,email:#email})})
}
struct Mode<'a> {
    rd: &'a Tokens,
    borrow: bool,
}
impl Mode<'_> {
    fn tr(&self) -> Tokens {
        let rd = self.rd;
        if self.borrow {
            quote!(#rd::BorrowType<'__rydantic_de>)
        } else {
            quote!(#rd::JsonType)
        }
    }
    fn decode(&self, ty: &Type, raw: Tokens, coerce: bool) -> Tokens {
        let tr = self.tr();
        if self.borrow {
            quote!(<#ty as #tr>::decode(#raw,__rydantic_ctx,#coerce))
        } else {
            quote!(<#ty as #tr>::decode_input(#raw,__rydantic_ctx,#coerce))
        }
    }
}
fn default_expr(field: &Field, borrow: bool) -> ::core::option::Option<Tokens> {
    let ty = &field.ty;
    let a = &field.attr;
    if a.default_trait {
        Some(quote!(<#ty as ::core::default::Default>::default()))
    } else if let Some(expr) = &a.default {
        Some(
            if matches!(
                expr,
                Expr::Lit(syn::ExprLit {
                    lit: syn::Lit::Str(_),
                    ..
                })
            ) {
                if borrow {
                    quote!(::core::convert::From::from(#expr))
                } else {
                    quote!((#expr).to_owned())
                }
            } else {
                quote!(#expr)
            },
        )
    } else {
        a.default_factory.as_ref().map(|path| quote!(#path()))
    }
}
fn field_value(field: &Field, raw: Tokens, mode: &Mode) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let ty = &field.ty;
    let rule = rules(field, rd);
    let missing_error = quote!({__rydantic_ctx.push(#rd::ValidationError::new("missing","field is required").with_stage(#rd::Stage::Parse));None});
    let default = default_expr(field, mode.borrow);
    let missing = if let Some(value) = default {
        quote!(Some({let value:#ty=#value;value}))
    } else if field.attr.required {
        missing_error.clone()
    } else {
        quote!(match <#ty as #tr>::missing(){Some(value)=>Some(value),None=>#missing_error})
    };
    let before=field.attr.before.as_ref().map(|path|quote!{
        let value=__rydantic_raw.into_value(__rydantic_ctx)?;
        __rydantic_raw=match #path(value){Ok(value)=>#rd::Input::Owned(value),Err(error)=>{__rydantic_ctx.push(error.with_stage(#rd::Stage::Parse));return None;}};
    });
    let decoded = mode.decode(ty, quote!(__rydantic_raw), field.attr.coerce);
    let default_flow = if field.attr.before.is_some() {
        quote! {let value:#ty=#missing?;let value=<#ty as #tr>::encode_input(&value,__rydantic_ctx);let mut __rydantic_raw=#rd::Input::Owned(value);#before #decoded?}
    } else {
        quote! {let value:#ty=#missing?;<#ty as #tr>::prepare_default(value,__rydantic_ctx)?}
    };
    let custom=field.attr.validate.as_ref().map(|path|quote!{if __rydantic_ctx.error_count()==__rydantic_start{if let Err(error)=#path(&__rydantic_value){__rydantic_ctx.push(error);}}});
    let builtin=field.attr.has_rules().then(||quote!{let rules=#rule;__rydantic_value=<#ty as #tr>::normalize(__rydantic_value,rules,__rydantic_ctx)?;<#ty as #tr>::validate_rules(&__rydantic_value,rules,__rydantic_ctx);});
    quote! {
        let __rydantic_start=__rydantic_ctx.error_count();
        let mut __rydantic_value=match #raw{Some(mut __rydantic_raw)=>{#before #decoded?},None=>{#default_flow}};
        #builtin #custom Some(__rydantic_value)
    }
}
fn with_location(field: &Field, index: usize, shape: Shape, body: Tokens, _rd: &Tokens) -> Tokens {
    if field.attr.flatten || field.attr.extra || (shape == Shape::Tuple && index == usize::MAX) {
        quote! {(||{#body})()}
    } else if shape == Shape::Tuple {
        quote! {__rydantic_ctx.at(#index,|__rydantic_ctx|{#body})}
    } else {
        let input = &field.input;
        quote! {__rydantic_ctx.at(#input,|__rydantic_ctx|{#body})}
    }
}
fn object_names(fields: &[Field], rd: &Tokens, tag: ::core::option::Option<&str>) -> Tokens {
    let names=fields.iter().filter(|f|!f.attr.extra).map(|f|{let ty=&f.ty;let input=&f.input;let output=&f.output;let exclude=f.attr.exclude;
        if f.attr.flatten{quote!{if !(mode==#rd::SchemaMode::Output&&#exclude){names.extend(<#ty as #rd::ObjectType>::field_names(mode,seen));}}}
        else{quote!{if !(mode==#rd::SchemaMode::Output&&#exclude){names.push(if mode==#rd::SchemaMode::Input{#input}else{#output}.to_owned());}}}
    });
    let tag = tag.map(|tag| quote!(names.push(#tag.to_owned());));
    quote! {let mut names=::std::vec::Vec::<::std::string::String>::new();#tag #(#names)* names}
}
fn collision_checks(
    fields: &[Field],
    values: &[Tokens],
    rd: &Tokens,
    tag: ::core::option::Option<&str>,
) -> Tokens {
    let tag = tag.map(|key| quote!(names.push(#key.to_owned());));
    let entries = fields.iter().zip(values).map(|(field, value)| {
        let ty=&field.ty; let input=&field.input; let output=&field.output; let exclude=field.attr.exclude;
        if field.attr.flatten || field.attr.extra {
            quote! { if !(mode==#rd::SchemaMode::Output && #exclude) { names.extend(<#ty as #rd::ObjectType>::reserved_names(#value,mode)); } }
        } else {
            quote! { if !(mode==#rd::SchemaMode::Output && #exclude) { names.push(if mode==#rd::SchemaMode::Input { #input } else { #output }.to_owned()); } }
        }
    });
    let captures=fields.iter().filter(|f|f.attr.flatten||f.attr.extra).map(|f|{let ty=&f.ty;quote!(usize::from(<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new())))});
    quote! {
        if 0usize #(+ #captures)* > 1 { __rydantic_ctx.push(#rd::ValidationError::new("flatten_ambiguous","only one flattened field may capture unknown keys")); }
        for mode in [#rd::SchemaMode::Input,#rd::SchemaMode::Output] {
            let mut names=::std::vec::Vec::new(); #tag #(#entries)*
            #rd::__private::check_names(names,__rydantic_ctx);
        }
    }
}
fn layout_check(fields: &[Field], rd: &Tokens, tag: ::core::option::Option<&str>) -> Tokens {
    let names = object_names(fields, rd, tag);
    let catches=fields.iter().filter(|f|f.attr.extra||f.attr.flatten).map(|f|{let ty=&f.ty;quote!(usize::from(<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new())))});
    quote! {
        for mode in [#rd::SchemaMode::Input,#rd::SchemaMode::Output]{let seen=&mut ::std::collections::HashSet::<&'static str>::new();let names={#names};#rd::__private::check_names(names,__rydantic_ctx);}
        if 0usize #(+ #catches)*>1{__rydantic_ctx.push(#rd::ValidationError::new("flatten_ambiguous","only one flattened field may capture unknown keys"));return None;}
    }
}
fn parse_shape(
    fields: &[Field],
    shape: Shape,
    constructor: Tokens,
    container: &attrs::Container,
    mode: &Mode,
    tag: ::core::option::Option<&str>,
) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let count = fields.len();
    let newtype = shape == Shape::Tuple && count == 1;
    let mut parses = vec![];
    let locals = (0..count).map(field_ident).collect::<Vec<_>>();
    // Declared fields are consumed before flattened maps, independently of Rust field order.
    let mut order = (0..count).collect::<Vec<_>>();
    order.sort_by_key(|i| fields[*i].attr.flatten || fields[*i].attr.extra);
    for i in order {
        let field = &fields[i];
        let local = &locals[i];
        let ty = &field.ty;
        let input = &field.input;
        let has_default = field.attr.has_default();
        let raw = if shape == Shape::Named {
            if field.attr.flatten || field.attr.extra {
                quote! {{let names=<#ty as #rd::ObjectType>::field_names(#rd::SchemaMode::Input,&mut ::std::collections::HashSet::new());
                    let capture=<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new());
                    let mut object=::std::collections::BTreeMap::new();
                    for name in names{if let Some(value)=__rydantic_object.remove(&name){object.insert(name,value);}}
                    if capture{object.extend(::core::mem::take(&mut __rydantic_object));}
                    if object.is_empty()&&(<#ty as #tr>::allows_missing()||#has_default){None}else{Some(#rd::Input::Object(object))}
                }}
            } else {
                quote!(__rydantic_object.remove(#input))
            }
        } else if newtype {
            quote!(Some(__rydantic_raw))
        } else {
            quote!(__rydantic_items.next())
        };
        let body = field_value(field, raw, mode);
        let body = with_location(field, if newtype { usize::MAX } else { i }, shape, body, rd);
        if field.attr.flatten || field.attr.extra {
            let capture = quote!(<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new()));
            parses.push((
                i,
                quote! {if !#capture{#local= #body;}},
                quote! {if #capture{#local= #body;}},
            ));
        } else {
            parses.push((i, quote! {#local= #body;}, quote!()));
        }
    }
    let first = parses.iter().map(|(_, a, _)| a);
    let last = parses.iter().map(|(_, _, b)| b);
    let unknown=(!container.ignore_extra&&shape==Shape::Named).then(||quote!{for (key,_) in __rydantic_object{__rydantic_ctx.at(key,|ctx|ctx.push(#rd::ValidationError::new("extra_forbidden","unknown field").with_stage(#rd::Stage::Parse)));}});
    let setup = match shape {
        Shape::Named => {
            let check = layout_check(fields, rd, tag);
            quote! {let mut __rydantic_object=__rydantic_raw.object(__rydantic_ctx)?;#check}
        }
        Shape::Tuple if !newtype => {
            quote! {let items=__rydantic_raw.array(__rydantic_ctx)?;if items.len()!=#count{__rydantic_ctx.push(#rd::ValidationError::new("tuple_length",concat!("expected ",stringify!(#count)," tuple items")).with_param("expected",#count).with_param("actual",items.len()));return None;}let mut __rydantic_items=items.into_iter();}
        }
        Shape::Unit => {
            quote! {if !__rydantic_raw.is_null(){__rydantic_ctx.push(#rd::ValidationError::new("type_error","expected null").with_stage(#rd::Stage::Parse));return None;}}
        }
        _ => quote!(),
    };
    let collision = if shape == Shape::Named {
        let values = locals
            .iter()
            .map(|local| quote!(&#local))
            .collect::<Vec<_>>();
        collision_checks(fields, &values, rd, tag)
    } else {
        quote!()
    };
    let done = if count == 0 {
        quote!({#collision Some(#constructor)})
    } else {
        quote! {match (#(#locals,)*){(#(Some(#locals),)*)=>{#collision Some(#constructor)},_=>None}}
    };
    quote! {#setup #(let mut #locals=None;)* #(#first)* #(#last)* #unknown #done}
}
fn encode_shape(
    fields: &[Field],
    values: &[Tokens],
    shape: Shape,
    mode: &Mode,
    input: bool,
    tag: ::core::option::Option<(&str, &str)>,
) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let method = if input {
        format_ident!("encode_input")
    } else {
        format_ident!("encode")
    };
    let newtype = shape == Shape::Tuple && fields.len() == 1;
    if shape == Shape::Unit {
        return quote!(#rd::Value::Null);
    }
    let mut entries = vec![];
    for (i, (field, value)) in fields.iter().zip(values).enumerate() {
        if !input && field.attr.exclude {
            continue;
        }
        let ty = &field.ty;
        let key = if input { &field.input } else { &field.output };
        let encoded = quote!(<#ty as #tr>::#method(#value,__rydantic_ctx));
        if newtype {
            return encoded;
        }
        if shape == Shape::Tuple {
            entries.push(
                quote! {__rydantic_items.push(__rydantic_ctx.at(#i,|__rydantic_ctx|#encoded));},
            );
        } else if field.attr.flatten || field.attr.extra {
            entries.push(quote!{let value=#encoded;#rd::__private::merge(&mut __rydantic_object,value,__rydantic_ctx);});
        } else {
            entries.push(quote!{let value=__rydantic_ctx.at(#key,|__rydantic_ctx|#encoded);#rd::__private::merge(&mut __rydantic_object,#rd::__private::serde_json::json!({#key:value}),__rydantic_ctx);});
        }
    }
    if shape == Shape::Tuple {
        quote! {let mut __rydantic_items=::std::vec::Vec::new();#(#entries)* #rd::Value::Array(__rydantic_items)}
    } else {
        let tag=tag.map(|(tag,wire)|quote!{__rydantic_object.insert(#tag.to_owned(),#rd::__private::serde_json::json!(#wire));});
        quote! {let mut __rydantic_object=#rd::__private::serde_json::Map::new();#tag #(#entries)* #rd::Value::Object(__rydantic_object)}
    }
}
fn validate_fields(fields: &[Field], values: &[Tokens], shape: Shape, mode: &Mode) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let checks=fields.iter().zip(values).enumerate().map(|(i,(field,value))|{
        let ty=&field.ty;let rule=rules(field,rd);
        let builtin=field.attr.has_rules().then(||quote!(<#ty as #tr>::validate_rules(#value,#rule,__rydantic_ctx);));
        let custom=field.attr.validate.as_ref().map(|path|quote!(if let Err(error)=#path(#value){__rydantic_ctx.push(error);}));
        let body=quote!{let start=__rydantic_ctx.error_count();<#ty as #tr>::validate_into(#value,__rydantic_ctx);if start==__rydantic_ctx.error_count(){#builtin #custom}};
        with_location(field,if shape==Shape::Tuple&&fields.len()==1{usize::MAX}else{i},shape,body,rd)
    });
    let collision = if shape == Shape::Named {
        collision_checks(fields, values, rd, None)
    } else {
        quote!()
    };
    quote!(#(#checks;)* #collision)
}
fn async_fields(fields: &[Field], values: &[Tokens], shape: Shape, rd: &Tokens) -> Tokens {
    let checks=fields.iter().zip(values).enumerate().map(|(i,(field,value))|{
        let ty=&field.ty;let input=&field.input;
        let segment=if field.attr.flatten||field.attr.extra||(shape==Shape::Tuple&&fields.len()==1){quote!(None)}else if shape==Shape::Tuple{quote!(Some(#rd::PathSegment::from(#i)))}else{quote!(Some(#rd::PathSegment::from(#input)))};
        let custom=field.attr.async_validate.as_ref().map(|path|quote!{if child.error_count()==start{if let Err(error)=#path(#value).await{child.push(error);}}});
        quote!{let mut child=__rydantic_ctx.child(#segment);let start=child.error_count();<#ty as #rd::AsyncCheck>::check_async(#value,&mut child).await;#custom __rydantic_ctx.absorb(child);}
    });
    quote!(#(#checks)*)
}
fn property_schema(field: &Field, mode: &Mode) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let ty = &field.ty;
    let coerce = field.attr.coerce;
    let rule = rules(field, rd);
    let before=field.attr.before.as_ref().map(|path|quote!{if __rydantic_ctx.mode==#rd::SchemaMode::Input{property=#rd::__private::serde_json::json!({});#rd::schema::annotate_local(&mut property,concat!("before:",stringify!(#path)));}});
    let condition = if field.attr.before.is_some() {
        quote!(__rydantic_ctx.mode==#rd::SchemaMode::Output)
    } else {
        quote!(true)
    };
    let custom=field.attr.validate.iter().map(|path|quote!(#rd::schema::annotate_local(&mut property,concat!("validate:",stringify!(#path)));));
    let asynchronous=field.attr.async_validate.iter().map(|path|quote!(#rd::schema::annotate_local(&mut property,concat!("async_validate:",stringify!(#path)));));
    let desc = field
        .doc
        .as_ref()
        .map(|text| quote!(property["description"]=#rd::__private::serde_json::json!(#text);));
    let literal = field.attr.default.as_ref().and_then(|expr| match expr {
        Expr::Lit(v) => match &v.lit {
            syn::Lit::Str(v) => Some(serde_json::json!(v.value())),
            syn::Lit::Bool(v) => Some(serde_json::json!(v.value)),
            syn::Lit::Int(v) => v
                .base10_digits()
                .parse()
                .ok()
                .map(serde_json::Value::Number),
            syn::Lit::Float(v) => v
                .base10_digits()
                .parse()
                .ok()
                .map(serde_json::Value::Number),
            _ => None,
        },
        _ => None,
    });
    let annotation=literal.map(|v|{let text=v.to_string();quote!(if __rydantic_ctx.mode==#rd::SchemaMode::Input{property["default"]=#rd::__private::serde_json::from_str::<#rd::Value>(#text).expect("literal default");})});
    quote! {{let mut property=<#ty as #tr>::schema(__rydantic_ctx,#coerce);#before if #condition{#rule.apply_schema(&mut property,__rydantic_ctx.mode,#coerce,<#ty as #tr>::kind());}#(#custom)* #(#asynchronous)* #desc #annotation property}}
}
fn schema_shape(
    fields: &[Field],
    shape: Shape,
    container: &attrs::Container,
    mode: &Mode,
    tag: ::core::option::Option<(&str, &str)>,
) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    if shape == Shape::Unit {
        return quote!(#rd::__private::serde_json::json!({"type":"null"}));
    }
    if shape == Shape::Tuple {
        let props = fields.iter().map(|f| property_schema(f, mode));
        let count = fields.len();
        if count == 0 {
            return quote!(#rd::__private::serde_json::json!({"type":"array","items":false,"maxItems":0}));
        }
        if count == 1 {
            return props.into_iter().next().expect("one field");
        }
        return quote!(#rd::__private::serde_json::json!({"type":"array","prefixItems":[#((#props)),*],"items":false,"minItems":#count,"maxItems":#count}));
    }
    let ignore = container.ignore_extra;
    let known_names = object_names(fields, rd, tag.map(|(key, _)| key));
    let captures=fields.iter().filter(|f|f.attr.flatten||f.attr.extra).map(|f|{let ty=&f.ty;quote!(usize::from(<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new())))});
    let tag=tag.map(|(key,value)|quote!{schema["properties"][#key]=#rd::__private::serde_json::json!({"type":"string","const":#value});schema["required"].as_array_mut().expect("required").push(#rd::__private::serde_json::json!(#key));});
    let inserts=fields.iter().map(|f|{let ty=&f.ty;let input=&f.input;let output=&f.output;let exclude=f.attr.exclude;let required=f.attr.required;let default=f.attr.has_default();let property=property_schema(f,mode);
        let insert=if f.attr.flatten||f.attr.extra{
            let optional=quote!((__rydantic_ctx.mode==#rd::SchemaMode::Input&&#default)||((!#required||__rydantic_ctx.mode==#rd::SchemaMode::Output)&&<#ty as #tr>::allows_missing()));
            quote!{let child=#property;#rd::__private::flatten_schema(&mut schema,child,(#optional),<#ty as #rd::ObjectType>::captures_extra(&mut ::std::collections::HashSet::new()),__rydantic_ctx);}
        }else{quote!{let key=if __rydantic_ctx.mode==#rd::SchemaMode::Input{#input}else{#output};let property=#property;schema["properties"].as_object_mut().expect("properties").insert(key.to_owned(),property);if __rydantic_ctx.mode==#rd::SchemaMode::Output||#required||(!#default&&!<#ty as #tr>::allows_missing()){schema["required"].as_array_mut().expect("required").push(#rd::__private::serde_json::json!(key));}}};
        quote!{if !(__rydantic_ctx.mode==#rd::SchemaMode::Output&&#exclude){#insert}}
    });
    quote! {{let mut schema=#rd::__private::serde_json::json!({"type":"object","properties":{},"required":[],"allOf":[],"additionalProperties":(#ignore&&__rydantic_ctx.mode==#rd::SchemaMode::Input)});#tag #(#inserts)*
    let captures=0usize #(+ #captures)*;
    if captures>1 { schema["allOf"].as_array_mut().expect("allOf").push(#rd::Value::Bool(false)); }
    let mut views=::std::vec::Vec::new();
    for mode in [#rd::SchemaMode::Input,#rd::SchemaMode::Output] {
        let seen=&mut ::std::collections::HashSet::<&'static str>::new(); let names={#known_names};
        let mut unique=::std::collections::HashSet::new();
        if names.iter().any(|name|!unique.insert(name)) { schema["allOf"].as_array_mut().expect("allOf").push(#rd::Value::Bool(false)); }
        views.push(names);
    }
    let mut required=::std::collections::HashSet::new();
    schema["required"].as_array_mut().expect("required").retain(|key|required.insert(key.as_str().expect("key").to_owned()));
    if captures>0 && views[0]!=views[1] && __rydantic_ctx.mode==#rd::SchemaMode::Input {#rd::schema::annotate_local(&mut schema,"extra_alias_collision");}
    if schema["allOf"].as_array().is_some_and(|v|v.is_empty()){schema.as_object_mut().expect("schema").remove("allOf");}schema}}
}
fn constructor(fields: &[Field], shape: Shape, path: Tokens) -> Tokens {
    let locals = (0..fields.len()).map(field_ident).collect::<Vec<_>>();
    let names = fields.iter().map(|f| &f.ident);
    match shape {
        Shape::Named => quote!(#path{#(#names:#locals,)*}),
        Shape::Tuple => quote!(#path(#(#locals,)*)),
        Shape::Unit => path,
    }
}
fn pattern(fields: &[Field], shape: Shape, path: Tokens) -> (Tokens, Vec<Tokens>) {
    let locals = (0..fields.len()).map(field_ident).collect::<Vec<_>>();
    let names = fields.iter().map(|f| &f.ident);
    let values = locals.iter().map(|l| quote!(#l)).collect();
    let pat = match shape {
        Shape::Named => quote!(#path{#(#names:#locals,)*}),
        Shape::Tuple => quote!(#path(#(#locals,)*)),
        Shape::Unit => path,
    };
    (pat, values)
}
fn prepare_fields(fields: &[Field], shape: Shape, mode: &Mode, path: Tokens) -> Tokens {
    let rd = mode.rd;
    let tr = mode.tr();
    let (pat, _) = pattern(fields, shape, path.clone());
    let constructor = constructor(fields, shape, path);
    let locals = (0..fields.len()).map(field_ident).collect::<Vec<_>>();
    let prepare=fields.iter().enumerate().map(|(i,f)|{let ty=&f.ty;let local=&locals[i];let rule=rules(f,rd);
        let raw=if let Some(path)=&f.attr.before{let decoded=mode.decode(ty,quote!(#rd::Input::Owned(raw)),f.attr.coerce);quote!{let raw=<#ty as #tr>::encode_input(&#local,__rydantic_ctx);let raw=match #path(raw){Ok(v)=>v,Err(e)=>{__rydantic_ctx.push(e.with_stage(#rd::Stage::Parse));return None;}};let mut value=#decoded?;}}
        else{quote!(let mut value=<#ty as #tr>::prepare_default(#local,__rydantic_ctx)?;)};
        let builtin=f.attr.has_rules().then(||quote!{value=<#ty as #tr>::normalize(value,#rule,__rydantic_ctx)?;<#ty as #tr>::validate_rules(&value,#rule,__rydantic_ctx);});
        let custom=f.attr.validate.as_ref().map(|path|quote!{if start==__rydantic_ctx.error_count(){if let Err(error)=#path(&value){__rydantic_ctx.push(error);}}});
        let body=quote!{let start=__rydantic_ctx.error_count();#raw #builtin #custom Some(value)};
        let body=with_location(f,if shape==Shape::Tuple&&fields.len()==1{usize::MAX}else{i},shape,body,rd);quote!(let #local=#body;)
    });
    let done = if fields.is_empty() {
        quote!(Some(#constructor))
    } else {
        quote!(match (#(#locals,)*){(#(Some(#locals),)*)=>Some(#constructor),_=>None})
    };
    quote!(#pat=>{#(#prepare)* #done})
}
fn expand(input: DeriveInput) -> syn::Result<Tokens> {
    let rd = match proc_macro_crate::crate_name("rydantic")
        .map_err(|e| syn::Error::new(input.ident.span(), e))?
    {
        proc_macro_crate::FoundCrate::Itself => quote!(::rydantic),
        proc_macro_crate::FoundCrate::Name(name) => {
            let name = format_ident!("{name}");
            quote!(::#name)
        }
    };
    let container = attrs::container(&input.attrs)?;
    let native_capnp = native::expand(&input, &container, &rd)?;
    let name = &input.ident;
    let title = container.title.clone().unwrap_or_else(|| name.to_string());
    let borrowed = input.generics.lifetimes().next().is_some();
    let mode = Mode {
        rd: &rd,
        borrow: borrowed,
    };
    let tr = mode.tr();
    let mut all_fields = Vec::new();
    let mut object_impl = None;
    let (decode, encode, encode_input, validate, schema, asynchronous, kind) = match &input.data {
        Data::Struct(data) => {
            if container.tag.is_some() || container.untagged {
                return Err(syn::Error::new(
                    name.span(),
                    "tag and untagged are supported on enums",
                ));
            }
            let fields = fields(&data.fields, None, &container)?;
            let shape = shape(&data.fields);
            let ctor = constructor(&fields, shape, quote!(Self));
            let decode = parse_shape(&fields, shape, ctor, &container, &mode, None);
            let values = fields
                .iter()
                .map(|f| {
                    let m = &f.member;
                    quote!(&self.#m)
                })
                .collect::<Vec<_>>();
            let encode = encode_shape(&fields, &values, shape, &mode, false, None);
            let encode_input = encode_shape(&fields, &values, shape, &mode, true, None);
            let validate = validate_fields(&fields, &values, shape, &mode);
            let schema = schema_shape(&fields, shape, &container, &mode, None);
            let asynchronous = async_fields(&fields, &values, shape, &rd);
            let kind = match shape {
                Shape::Named => quote!(#rd::TypeKind::Object),
                Shape::Tuple if fields.len() == 1 => {
                    let ty = &fields[0].ty;
                    quote!(<#ty as #tr>::kind())
                }
                Shape::Tuple => quote!(#rd::TypeKind::Array),
                Shape::Unit => quote!(#rd::TypeKind::Any),
            };
            if shape == Shape::Named {
                let names = object_names(&fields, &rd, None);
                let present=fields.iter().map(|f|{let ty=&f.ty;let member=&f.member;let input=&f.input;let output=&f.output;let exclude=f.attr.exclude;
                    if f.attr.flatten||f.attr.extra{quote!{if !(mode==#rd::SchemaMode::Output&&#exclude){names.extend(<#ty as #rd::ObjectType>::reserved_names(&self.#member,mode));}}}
                    else{quote!{if !(mode==#rd::SchemaMode::Output&&#exclude){names.push(if mode==#rd::SchemaMode::Input{#input}else{#output}.to_owned());}}}
                });
                let extra = fields
                    .iter()
                    .filter(|f| f.attr.flatten || f.attr.extra)
                    .map(|f| {
                        let ty = &f.ty;
                        quote!(<#ty as #rd::ObjectType>::captures_extra(seen))
                    });
                object_impl = Some(quote! {
                    fn reserved_names(&self,mode:#rd::SchemaMode)->::std::vec::Vec<::std::string::String>{let mut names=::std::vec::Vec::new();#(#present)* names}
                    fn field_names(mode:#rd::SchemaMode,seen:&mut ::std::collections::HashSet<&'static str>)->::std::vec::Vec<::std::string::String>{if !seen.insert(::core::any::type_name::<Self>()){return ::std::vec::Vec::new();}let names={#names};seen.remove(::core::any::type_name::<Self>());names}
                    fn captures_extra(seen:&mut ::std::collections::HashSet<&'static str>)->bool{if !seen.insert(::core::any::type_name::<Self>()){return false;}let captures=false #(|| #extra)*;seen.remove(::core::any::type_name::<Self>());captures}
                });
            }
            all_fields.extend(fields);
            (
                decode,
                encode,
                encode_input,
                validate,
                schema,
                asynchronous,
                kind,
            )
        }
        Data::Enum(data) => {
            if data.variants.is_empty() {
                return Err(syn::Error::new(
                    name.span(),
                    "Model requires at least one enum variant",
                ));
            }
            let mut variants = vec![];
            let mut seen = std::collections::HashSet::new();
            for v in &data.variants {
                let wire = attrs::variant_name(&v.attrs, &v.ident.to_string())?;
                if !seen.insert(wire.clone()) {
                    return Err(syn::Error::new(
                        v.ident.span(),
                        "duplicate enum variant name",
                    ));
                }
                let shape = shape(&v.fields);
                if container.tag.is_some() && shape == Shape::Tuple {
                    return Err(syn::Error::new(v.ident.span(),"internally tagged enums require named fields or unit variants; use untagged for tuple variants"));
                }
                if container.tag.is_none() && !container.untagged && shape != Shape::Unit {
                    return Err(syn::Error::new(
                        v.ident.span(),
                        "enums with fields require #[model(tag = \"...\")] or #[model(untagged)]",
                    ));
                }
                variants.push((
                    &v.ident,
                    wire,
                    shape,
                    fields(&v.fields, container.tag.as_deref(), &container)?,
                ));
            }
            let mut decodes = vec![];
            let mut encodes = vec![];
            let mut input_encodes = vec![];
            let mut validates = vec![];
            let mut asyncs = vec![];
            let mut schemas = vec![];
            let wires = variants.iter().map(|(_, w, _, _)| w).collect::<Vec<_>>();
            for (variant, wire, shape, fields) in &variants {
                let (pat, values) = pattern(fields, *shape, quote!(Self::#variant));
                let ctor = constructor(fields, *shape, quote!(Self::#variant));
                let wire_shape = if container.tag.is_some() {
                    Shape::Named
                } else {
                    *shape
                };
                let tag = container.tag.as_deref().map(|t| (t, wire.as_str()));
                let (encode, encode_input, schema) =
                    if !container.untagged && container.tag.is_none() {
                        (
                            quote!(#rd::__private::serde_json::json!(#wire)),
                            quote!(#rd::__private::serde_json::json!(#wire)),
                            quote!(),
                        )
                    } else {
                        (
                            encode_shape(fields, &values, wire_shape, &mode, false, tag),
                            encode_shape(fields, &values, wire_shape, &mode, true, tag),
                            schema_shape(fields, wire_shape, &container, &mode, tag),
                        )
                    };
                encodes.push(quote!(#pat=>{#encode}));
                input_encodes.push(quote!(#pat=>{#encode_input}));
                let checks = validate_fields(fields, &values, *shape, &mode);
                validates.push(quote!(#pat=>{#checks}));
                let checks = async_fields(fields, &values, *shape, &rd);
                asyncs.push(quote!(#pat=>{#checks}));
                schemas.push(schema);
                if container.untagged {
                    let body = parse_shape(fields, *shape, ctor, &container, &mode, None);
                    decodes.push(quote!{
                        {let mut trial=#rd::Context::new();let result={let __rydantic_ctx=&mut trial;let __rydantic_raw=__rydantic_raw.clone();(||{#body})()};
                        match trial.finish(result){Ok(value)=>return Some(value),Err(errors)=>__rydantic_branches.push(#rd::__private::serde_json::json!({"variant":#wire,"errors":errors.to_json()}))}}
                    });
                } else if container.tag.is_some() {
                    let body = parse_shape(
                        fields,
                        wire_shape,
                        ctor,
                        &container,
                        &mode,
                        container.tag.as_deref(),
                    );
                    decodes.push(quote!(#wire=>{let __rydantic_raw=#rd::Input::Object(__rydantic_object);#body}));
                } else {
                    decodes.push(quote!(#wire=>Some(#ctor)));
                }
            }
            let (decode, schema, kind) = if container.untagged {
                (
                    quote! {let mut __rydantic_branches=::std::vec::Vec::<#rd::Value>::new();#(#decodes)* __rydantic_ctx.push(#rd::ValidationError::new("union_no_match","no untagged variant accepted the value").with_stage(#rd::Stage::Parse).with_param("branches",#rd::Value::Array(__rydantic_branches)));None},
                    quote!(#rd::__private::serde_json::json!({"anyOf":[#((#schemas)),*]})),
                    quote!(#rd::TypeKind::Any),
                )
            } else if let Some(tag) = &container.tag {
                (
                    quote! {let mut __rydantic_object=__rydantic_raw.object(__rydantic_ctx)?;let tag=match __rydantic_object.remove(#tag){Some(raw)=>{let value=raw.into_value(__rydantic_ctx)?;match value{#rd::Value::String(value)=>value,_=>{__rydantic_ctx.at(#tag,|ctx|ctx.push(#rd::ValidationError::new("union_tag_type","discriminator must be a string").with_stage(#rd::Stage::Parse)));return None;}}},None=>{__rydantic_ctx.at(#tag,|ctx|ctx.push(#rd::ValidationError::new("union_tag_missing","discriminator is required").with_stage(#rd::Stage::Parse)));return None;}};
                    match tag.as_str(){#(#decodes,)* _=>{__rydantic_ctx.at(#tag,|ctx|ctx.push(#rd::ValidationError::new("union_tag_invalid","unknown discriminator").with_stage(#rd::Stage::Parse).with_param("expected",#rd::__private::serde_json::json!([#(#wires),*]))));None}}},
                    quote!(#rd::__private::serde_json::json!({"oneOf":[#((#schemas)),*],"discriminator":{"propertyName":#tag}})),
                    quote!(#rd::TypeKind::Object),
                )
            } else {
                (
                    quote! {let raw=__rydantic_raw.into_value(__rydantic_ctx)?;match raw.as_str(){Some(wire)=>match wire{#(#decodes,)* _=>{__rydantic_ctx.push(#rd::ValidationError::new("enum","unknown enum value").with_stage(#rd::Stage::Parse).with_param("expected",#rd::__private::serde_json::json!([#(#wires),*])));None}},None=>{__rydantic_ctx.push(#rd::ValidationError::new("type_error","expected enum string").with_stage(#rd::Stage::Parse));None}}},
                    quote!(#rd::__private::serde_json::json!({"type":"string","enum":[#(#wires),*]})),
                    quote!(#rd::TypeKind::String),
                )
            };
            for (_, _, _, fields) in variants {
                all_fields.extend(fields);
            }
            (
                decode,
                quote!(match self{#(#encodes,)*}),
                quote!(match self{#(#input_encodes,)*}),
                quote!(match self{#(#validates,)*}),
                schema,
                quote!(match self{#(#asyncs,)*}),
                kind,
            )
        }
        Data::Union(_) => {
            return Err(syn::Error::new(
                name.span(),
                "Model cannot be derived for unions",
            ))
        }
    };
    let prepare_default = {
        let arms = match &input.data {
            Data::Struct(data) => {
                let fields = fields(&data.fields, None, &container)?;
                let arm = prepare_fields(&fields, shape(&data.fields), &mode, quote!(Self));
                quote!(#arm)
            }
            Data::Enum(data) => {
                let mut arms = vec![];
                for v in &data.variants {
                    let variant = &v.ident;
                    let fields = fields(&v.fields, container.tag.as_deref(), &container)?;
                    arms.push(prepare_fields(
                        &fields,
                        shape(&v.fields),
                        &mode,
                        quote!(Self::#variant),
                    ));
                }
                quote!(#(#arms,)*)
            }
            _ => unreachable!(),
        };
        let custom=container.validate.as_ref().map(|path|quote!{if start==ctx.error_count(){if let Some(value)=&value{if let Err(errors)=#path(value){ctx.extend(errors);}}}});
        quote! {fn prepare_default(self,ctx:&mut #rd::Context)->::core::option::Option<Self>{let start=ctx.error_count();let value={let __rydantic_ctx=&mut *ctx;match self{#arms}};#custom value}}
    };
    let mut generics = input.generics.clone();
    if borrowed {
        generics.params.insert(0, parse_quote!('__rydantic_de));
        for lt in input.generics.lifetimes() {
            let lt = &lt.lifetime;
            generics
                .make_where_clause()
                .predicates
                .push(parse_quote!('__rydantic_de:#lt));
        }
    }
    for p in generics.type_params_mut() {
        p.bounds.push(parse_quote!(#tr));
    }
    fn contains_generic(ty: &Type, ident: &Ident) -> bool {
        match ty{Type::Path(p)=>p.path.segments.iter().any(|s|s.ident==*ident||matches!(&s.arguments,syn::PathArguments::AngleBracketed(a) if a.args.iter().any(|arg|matches!(arg,syn::GenericArgument::Type(t)if contains_generic(t,ident))))),Type::Array(a)=>contains_generic(&a.elem,ident),Type::Reference(r)=>contains_generic(&r.elem,ident),Type::Tuple(t)=>t.elems.iter().any(|t|contains_generic(t,ident)),_=>false}
    }
    let mut assertions = vec![];
    for f in &all_fields {
        let ty = &f.ty;
        let a = &f.attr;
        let generic = input
            .generics
            .type_params()
            .any(|p| contains_generic(ty, &p.ident));
        let mut bounds = vec![];
        if a.trim || a.lowercase || a.uppercase || a.email || a.pattern.is_some() {
            assertions.push(quote!(__rydantic_assert_string::<#ty>();));
            bounds.push(quote!(#rd::StringType));
        }
        if a.min_length.is_some() || a.max_length.is_some() {
            assertions.push(quote!(__rydantic_assert_length::<#ty>();));
            bounds.push(quote!(#rd::LengthType));
        }
        if a.ge.is_some() || a.gt.is_some() || a.le.is_some() || a.lt.is_some() {
            assertions.push(quote!(__rydantic_assert_number::<#ty>();));
            bounds.push(quote!(#rd::NumericType));
        }
        if a.flatten {
            bounds.push(quote!(#rd::ObjectType));
        }
        if a.extra {
            bounds.push(quote!(#rd::ExtraFields));
            assertions.push(quote!(__rydantic_assert_extra::<#ty>();));
        }
        if a.default_trait {
            bounds.push(quote!(::core::default::Default));
        }
        if generic {
            for bound in bounds {
                generics
                    .make_where_clause()
                    .predicates
                    .push(parse_quote!(#ty:#bound));
            }
        }
    }
    let (_, ty_generics, _) = input.generics.split_for_impl();
    let (impl_generics, _, where_clause) = generics.split_for_impl();
    let mut de_generics = generics.clone();
    if !borrowed {
        de_generics.params.insert(0, parse_quote!('__rydantic_de));
    }
    let (de_impl_generics, _, de_where_clause) = de_generics.split_for_impl();
    let custom_parse=container.validate.as_ref().map(|path|quote!{if __rydantic_ctx.error_count()==start{if let Some(value)=&value{if let Err(errors)=#path(value){__rydantic_ctx.extend(errors);}}}});
    let custom_validate=container.validate.as_ref().map(|path|quote!{if __rydantic_ctx.error_count()==start{if let Err(errors)=#path(self){__rydantic_ctx.extend(errors);}}});
    let schema_custom=container.validate.as_ref().map(|path|quote!(#rd::schema::annotate_local(&mut schema,concat!("validate:",stringify!(#path)));));
    let schema_async=container.async_validate.as_ref().map(|path|quote!(#rd::schema::annotate_local(&mut schema,concat!("async_validate:",stringify!(#path)));));
    let direct_async = container.async_validate.is_some()
        || all_fields.iter().any(|f| f.attr.async_validate.is_some());
    let nested_async = all_fields.iter().map(|f| {
        let ty = &f.ty;
        quote!(<#ty as #tr>::async_required(seen))
    });
    let model_impl = if borrowed {
        quote!(impl #impl_generics #rd::BorrowModel<'__rydantic_de> for #name #ty_generics #where_clause {})
    } else {
        quote!(impl #impl_generics #rd::Model for #name #ty_generics #where_clause {})
    };
    let dump = if borrowed {
        quote!(<Self as #rd::BorrowModel<'__rydantic_de>>::dump(self))
    } else {
        quote!(<Self as #rd::Model>::dump(self))
    };
    let deserialize = if borrowed {
        quote! {let raw=<&'__rydantic_de #rd::__private::serde_json::value::RawValue as #rd::__private::serde::Deserialize>::deserialize(deserializer)?;<Self as #rd::BorrowModel<'__rydantic_de>>::parse_raw(raw).map_err(#rd::__private::serde::de::Error::custom)}
    } else {
        quote! {let raw=<::std::boxed::Box<#rd::RawValue> as #rd::__private::serde::Deserialize>::deserialize(deserializer)?;<Self as #rd::Model>::parse_raw(&raw).map_err(#rd::__private::serde::de::Error::custom)}
    };
    let object_impl=object_impl.map(|body|quote!(impl #impl_generics #rd::ObjectType for #name #ty_generics #where_clause{#body}));
    let bridge=(!borrowed).then(||quote!{
        impl #de_impl_generics #rd::BorrowType<'__rydantic_de> for #name #ty_generics #de_where_clause{
            fn decode(raw:#rd::Input<'__rydantic_de>,ctx:&mut #rd::Context,coerce:bool)->::core::option::Option<Self>{<Self as #rd::JsonType>::decode_input(raw,ctx,coerce)}
            fn prepare_default(self,ctx:&mut #rd::Context)->::core::option::Option<Self>{<Self as #rd::JsonType>::prepare_default(self,ctx)}
            fn encode(&self,ctx:&mut #rd::Context)->#rd::Value{<Self as #rd::JsonType>::encode(self,ctx)}
            fn encode_input(&self,ctx:&mut #rd::Context)->#rd::Value{<Self as #rd::JsonType>::encode_input(self,ctx)}
            fn schema(ctx:&mut #rd::SchemaContext,coerce:bool)->#rd::Value{<Self as #rd::JsonType>::schema(ctx,coerce)}
            fn validate_into(&self,ctx:&mut #rd::Context){<Self as #rd::JsonType>::validate_into(self,ctx)}
            fn normalize(self,rules:&#rd::rules::Rules,ctx:&mut #rd::Context)->::core::option::Option<Self>{<Self as #rd::JsonType>::normalize(self,rules,ctx)}
            fn validate_rules(&self,rules:&#rd::rules::Rules,ctx:&mut #rd::Context){<Self as #rd::JsonType>::validate_rules(self,rules,ctx)}
            fn async_required(seen:&mut ::std::collections::HashSet<&'static str>)->bool{<Self as #rd::JsonType>::async_required(seen)}
            fn kind()->#rd::TypeKind{<Self as #rd::JsonType>::kind()}
        }
    });
    let mut async_generics = input.generics.clone();
    for p in async_generics.type_params_mut() {
        p.bounds.push(parse_quote!(#rd::AsyncCheck));
    }
    let (async_impl_generics, _, async_where_clause) = async_generics.split_for_impl();
    let custom_async=container.async_validate.as_ref().map(|path|quote!{if start==__rydantic_ctx.error_count(){if let Err(errors)=#path(self).await{__rydantic_ctx.extend(errors);}}});
    let body = quote! {
        // Mixed-site hygiene does not isolate item names. Keep assertion helpers
        // outside the scope containing user callback paths and default expressions.
        {
            fn __rydantic_assert_string<T:#rd::StringType>(){}fn __rydantic_assert_length<T:#rd::LengthType>(){}fn __rydantic_assert_number<T:#rd::NumericType>(){}fn __rydantic_assert_extra<T:#rd::ExtraFields>(){}
            #(#assertions)*
        }
        let start=__rydantic_ctx.error_count();let value=(||{#decode})();#custom_parse value
    };
    let decode_methods = if borrowed {
        quote! {fn decode(__rydantic_raw:#rd::Input<'__rydantic_de>,__rydantic_ctx:&mut #rd::Context,_coerce:bool)->::core::option::Option<Self>{#body}}
    } else {
        quote! {
            fn decode(raw:#rd::Value,ctx:&mut #rd::Context,coerce:bool)->::core::option::Option<Self>{<Self as #rd::JsonType>::decode_input(#rd::Input::Owned(raw),ctx,coerce)}
            fn decode_input(__rydantic_raw:#rd::Input<'_>,__rydantic_ctx:&mut #rd::Context,_coerce:bool)->::core::option::Option<Self>{#body}
        }
    };
    Ok(quote! {
        impl #impl_generics #tr for #name #ty_generics #where_clause{
            #decode_methods
            #prepare_default
            fn encode(&self,__rydantic_ctx:&mut #rd::Context)->#rd::Value{#encode}
            fn encode_input(&self,__rydantic_ctx:&mut #rd::Context)->#rd::Value{#encode_input}
            fn validate_into(&self,__rydantic_ctx:&mut #rd::Context){let start=__rydantic_ctx.error_count();#validate #custom_validate}
            fn schema(__rydantic_ctx:&mut #rd::SchemaContext,_coerce:bool)->#rd::Value{__rydantic_ctx.reference(::core::any::type_name::<Self>(),|__rydantic_ctx|{let mut schema=#schema;schema["title"]=#rd::__private::serde_json::json!(#title);#schema_custom #schema_async schema})}
            fn kind()->#rd::TypeKind{#kind}
            fn async_required(seen:&mut ::std::collections::HashSet<&'static str>)->bool{if !seen.insert(::core::any::type_name::<Self>()){return false;}#direct_async #(|| #nested_async)*}
        }
        #model_impl #object_impl #bridge #native_capnp
        impl #async_impl_generics #rd::AsyncCheck for #name #ty_generics #async_where_clause{
            fn check_async<'__rydantic_future>(&'__rydantic_future self,__rydantic_ctx:&'__rydantic_future mut #rd::Context)->#rd::BoxFuture<'__rydantic_future,()>{
                ::std::boxed::Box::pin(async move{let start=__rydantic_ctx.error_count();#asynchronous #custom_async})
            }
        }
        impl #impl_generics #rd::__private::serde::Serialize for #name #ty_generics #where_clause{
            fn serialize<S:#rd::__private::serde::Serializer>(&self,serializer:S)->::core::result::Result<S::Ok,S::Error>{let value=#dump.map_err(#rd::__private::serde::ser::Error::custom)?;#rd::__private::serde::Serialize::serialize(&value,serializer)}
        }
        impl #de_impl_generics #rd::__private::serde::Deserialize<'__rydantic_de> for #name #ty_generics #de_where_clause{
            fn deserialize<D:#rd::__private::serde::Deserializer<'__rydantic_de>>(deserializer:D)->::core::result::Result<Self,D::Error>{#deserialize}
        }
    })
}