#[derive(TryFromMultipart)]
struct ParsePdf {
    pdf: FieldData<TempFile>,
}

#[derive(TryFromMultipart)]
pub struct CreateRtypeInput {
    /// The record type
    pub r#type: String,
}

pub async fn post(
    ctx: Extension<Arc<ServerContext>>,
    TypedMultipart(input::CreateRtypeInput { r#type }): TypedMultipart<input::CreateRtypeInput>,
) -> Result<Response, crate::Error> {

use axum::{http::StatusCode, routing::post, Router};
use axum_typed_multipart::{TryFromMultipart, TypedMultipart};

#[derive(TryFromMultipart)]
struct RequestData {
    names: Vec<String>,
}

async fn handler(TypedMultipart(RequestData { names }): TypedMultipart<RequestData>) -> StatusCode {
    println!("names = {:?}", names);
    StatusCode::OK
}

#[tokio::main]
async fn main() {
    // build our application with a single route
    let app = Router::new().route("/", post(handler));

    // run it with hyper on localhost:3000
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

error[E0277]: the trait bound `fn(axum_typed_multipart::TypedMultipart<ttl::model::input::CreateTtlInput>, axum::Extension<std::sync::Arc<context::ServerContext>>) -> impl std::future::Future<Output = std::result::Result<axum::Json<ttl::model::TtlResponse>, errors::Error>> {ttl::query::post}: axum::handler::Handler<_, _, _>` is not satisfied
   --> src/routes.rs:51:38
    |
51  |         .route("/ttl/add/:ttl", post(ttl::query::post));
    |                                 ---- ^^^^^^^^^^^^^^^^ the trait `axum::handler::Handler<_, _, _>` is not implemented for fn item `fn(axum_typed_multipart::TypedMultipart<ttl::model::input::CreateTtlInput>, axum::Extension<std::sync::Arc<context::ServerContext>>) -> impl std::future::Future<Output = std::result::Result<axum::Json<ttl::model::TtlResponse>, errors::Error>> {ttl::query::post}`
    |                                 |
    |                                 required by a bound introduced by this call
    |
    = help: the following other types implement trait `axum::handler::Handler<T, S, B>`:
              <axum::handler::Layered<L, H, T, S, B, B2> as axum::handler::Handler<T, S, B2>>
              <axum::routing::MethodRouter<S, B> as axum::handler::Handler<(), S, B>>
note: required by a bound in `axum::routing::post`
   --> /var/home/user/.local/share/cargo/registry/src/github.com-1ecc6299db9ec823/axum-0.6.12/src/routing/method_routing.rs:407:1
    |
407 | top_level_handler_fn!(post, POST);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `post`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

        .route("/ttl/list/:id", get(ttl::query::get))
        .route("/ttl/add/:ttl", post(ttl::query::post)); // ⚠️ the line that causes the error

pub async fn post(
    TypedMultipart(input::CreateTtlInput { ttl }): TypedMultipart<input::CreateTtlInput>,
    ctx: Extension<Arc<ServerContext>>,
) -> Result<Json<model::TtlResponse>, crate::Error> {

// file `typed_multipart.rs`
#[cfg(feature = "validify")]
impl<T: validify::Validify, R> crate::HasValidify for BaseMultipart<T, R> {
    type Validify = T;
    type PayloadExtractor = BaseMultipart<T::Payload, R>;

    fn from_validified(data: Self::Validify) -> Self {
        BaseMultipart {
            data,
            rejection: Default::default(), // ❌: need rejection to be pub
        }
    }
}

// file `validify.rs`
/// Trait for types that can supply a reference that can be modified and validated using `validify`.
///
/// Extractor types `T` that implement this trait can be used with `Validified`.
///
pub trait HasValidify: Sized {
    /// Inner type that can be modified and validated using `validify`.
    type Validify: Validify;
    ///
    type PayloadExtractor: PayloadExtractor<Payload = <Self::Validify as Validify>::Payload>;
    ///
    fn from_validified(v: Self::Validify) -> Self;
}

#[async_trait]
impl<State, Extractor> FromRequestParts<State> for Validified<Extractor>
where
    State: Send + Sync,
    Extractor: HasValidify,
    Extractor::Validify: Validify,
    Extractor::PayloadExtractor: FromRequestParts<State>,
{
    type Rejection =
        ValidifyRejection<<Extractor::PayloadExtractor as FromRequestParts<State>>::Rejection>;

    async fn from_request_parts(parts: &mut Parts, state: &State) -> Result<Self, Self::Rejection> {
        let payload = Extractor::PayloadExtractor::from_request_parts(parts, state)
            .await
            .map_err(ValidifyRejection::Inner)?;
        Ok(Validified(Extractor::from_validified(
            Extractor::Validify::validify(payload.get_payload())?,
        )))
    }
}
// and impl FromRequest for Validified ...