#[automatically_derived]
#[derive(Debug)]
pub struct RawInner {
    pub code: f64,
}
#[automatically_derived]
#[allow(
    non_camel_case_types,
    non_snake_case,
    unused_variables,
    non_upper_case_globals
)]
impl ::valust::Validate for Inner {
    type Raw = RawInner;
    fn validate(raw: Self::Raw) -> Result<Self, ::valust::error::ValidationError> {
        let RawInner { code } = raw;
        let mut valust_impl_err_Inner = ::valust::error::ValidationError::new();
        valust_impl_err_Inner.check()?;
        let mut valust_impl_err_Inner = ::valust::error::ValidationError::new();
        fn valust_validate_code(
            code: f64,
            valust_err_code: &mut ::valust::error::ValidationError,
        ) -> Option<f64> {
            if !({ code > 10.0 }) {
                valust_err_code.push_validate_error(
                    ::valust::error::validate::ValidateError {
                        field: "code",
                        path: format!("{}", "code"),
                        value: format!("(f64) {:?}", code),
                        cause: ::std::option::Option::None,
                        message: ::std::option::Option::Some(
                            "code must be greater than 10.0",
                        ),
                        expression: "{code > 10.0}",
                        type_name: "f64",
                    },
                );
                return None;
            }
            Some(code)
        }
        let code: Option<f64> = valust_validate_code(code, &mut valust_impl_err_Inner);
        valust_impl_err_Inner.check()?;
        let code = code.expect("Unexpected error occurred in processing field `code`");
        let mut valust_impl_err_Inner = ::valust::error::ValidationError::new();
        valust_impl_err_Inner.check()?;
        Ok(Inner { code })
    }
}

#[automatically_derived]
#[derive(Debug)]
pub struct RawOuter {
    pub inner: ::valust::Raw<Inner>,
    pub extra: String,
}
#[automatically_derived]
#[allow(
    non_camel_case_types,
    non_snake_case,
    unused_variables,
    non_upper_case_globals
)]
impl ::valust::Validate for Outer {
    type Raw = RawOuter;
    fn validate(raw: Self::Raw) -> Result<Self, ::valust::error::ValidationError> {
        let RawOuter { inner, extra } = raw;
        let mut valust_impl_err_Outer = ::valust::error::ValidationError::new();
        valust_impl_err_Outer.check()?;
        let mut valust_impl_err_Outer = ::valust::error::ValidationError::new();
        fn valust_validate_inner(
            inner: ::valust::Raw<Inner>,
            valust_err_inner: &mut ::valust::error::ValidationError,
        ) -> Option<Inner> {
            let inner: Inner = match ::valust::Validate::validate(inner) {
                Ok(v_valust) => v_valust,
                Err(e_valust) => {
                    valust_err_inner.extend_error("inner", e_valust);
                    return None;
                }
            };
            Some(inner)
        }
        let inner: Option<Inner> =
            valust_validate_inner(inner, &mut valust_impl_err_Outer);
        fn valust_validate_extra(
            extra: String,
            valust_err_extra: &mut ::valust::error::ValidationError,
        ) -> Option<u32> {
            let extra = ({ extra.trim() });
            let extra = {
                let valust_format_err_clone_extra = extra.clone();
                match ((parse_to::<u32>)(extra)) {
                    ::std::result::Result::Ok(valust_v) => valust_v,
                    ::std::result::Result::Err(valust_trans_err_cause) => {
                        valust_err_extra.push_transform_error(
                            ::valust::error::transform::TransformError {
                                field: "extra",
                                path: format!("{}", "extra"),
                                value: format!(
                                    "(String) {:?}",
                                    valust_format_err_clone_extra
                                ),
                                cause: ::std::boxed::Box::new(valust_trans_err_cause),
                                message: ::std::option::Option::Some(
                                    "`extra`'s transform expression fails",
                                ),
                                expression: "(parse_to :: < u32 >) (extra)",
                                source_type_name: "String",
                                target_type_name: "<unknown>",
                            },
                        );
                        return None;
                    }
                }
            };
            Some(extra)
        }
        let extra: Option<u32> =
            valust_validate_extra(extra, &mut valust_impl_err_Outer);
        valust_impl_err_Outer.check()?;
        let inner =
            inner.expect("Unexpected error occurred in processing field `inner`");
        let extra =
            extra.expect("Unexpected error occurred in processing field `extra`");
        let mut valust_impl_err_Outer = ::valust::error::ValidationError::new();
        valust_impl_err_Outer.check()?;
        Ok(Outer { inner, extra })
    }
}