Axum get request traits won't line up for generics

Question

I've been testing out rust recently and decided to build a server using axum. I wanted to implement the endpoints in a generic form, so that I could create them easily in the future and to just play with generics in general. I've run into an issue where the traits Im giving to my types in the function definition aren't lining up with the traits needed by the get and put handlers. Ive looked thru the axum documentation for a while adding and removing traits, but haven't had any luck. Heres the router definition where the error occurs.

pub fn create_new_router<T, UP, QP>( config: EndpointsConfig ) -> Router where 
        T: for<'r> FromRow<'r, SqliteRow> + Send + Sync + 'static + Unpin + TableName, 
        UP: Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static + traits::Verification, 
        QP: Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static {
    let mut router = Router::new();

    for endpoint_config in config.endpoint_configs {
        match endpoint_config.verb {
            EndpointVerb::GET => {
                router = router.route( &format!("/{}", config.path_name), axum::routing::get( endpoints::http_get::<T, QP> ) );
            },
            EndpointVerb::POST => {
                router = router.route( &format!("/{}", config.path_name), axum::routing::post( endpoints::http_post::<T, UP> ) );
            },
            EndpointVerb::PUT => {
                router = router.route( &format!("/{}/:id", config.path_name), axum::routing::put( endpoints::http_put::<T, UP> ) );
            },
            EndpointVerb::DELETE => {
                router = router.route( &format!("/{}/:id", config.path_name), axum::routing::delete( endpoints::http_delete::<T> ) );
            }
        }
    }

    return router;
}

And then heres the Get and Post handler definitions.

pub async fn http_get<T, QP>( 
    Extension( connection_pool ): Extension<SqlitePool>, 
    Query( parameters ): Query<QP> ) -> Result<Json<Vec<T>>, StatusCode> 
    where T: for<'r> FromRow<'r, SqliteRow> + Send + Unpin + TableName, QP: Serialize {

    let map = convert_to_hashmap( &parameters );
    if let Ok( objects ) = read::<T>( &connection_pool, T::table_name(), &map, None ).await {
        Ok( Json( objects ) )
    } else {
        Err( StatusCode::INTERNAL_SERVER_ERROR )
    }
}

pub async fn http_post<T, UP>( 
    Extension( connection_pool ): Extension<SqlitePool>, 
    Json( params ): Json<UP> ) -> Result<Json<i32>, StatusCode> 
    where T: TableName, UP: Verification + Serialize {

    let map = convert_to_hashmap( &params );

    if params.verify() {
        if let Ok( id ) = create( &connection_pool, T::table_name(), &map).await {
            Ok( Json( id ) )
        } else {
            Err( StatusCode::INTERNAL_SERVER_ERROR )
        }
    } else {
        Err( StatusCode::BAD_REQUEST )
    }
}

I should mention oddly enough the Post and Delete handlers aren't giving me any errors yet the Get and Put both are. The help message is a bit foreign to me too, but maybe someone here is can make more sense of it than me.

error[E0277]: the trait bound `fn(Extension<Pool<Sqlite>>, axum::extract::Query<QP>) -> impl Future<Output = Result<axum::Json<Vec<T>>, StatusCode>> {http_get::<T, QP>}: Handler<_, _, _>` is not satisfied
   --> src/lib.rs:43:95
    |
43  |                 router = router.route( &format!("/{}", config.path_name), axum::routing::get( endpoints::http_get::<T, QP> ) );
    |                                                                           ------------------  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Handler<_, _, _>` is not implemented for fn item `fn(Extension<Pool<Sqlite>>, axum::extract::Query<QP>) -> impl Future<Output = Result<axum::Json<Vec<T>>, StatusCode>> {http_get::<T, QP>}`
    |                                                                           |
    |                                                                           required by a bound introduced by this call
    |
    = help: the following other types implement trait `Handler<T, S, B>`:
              <Layered<L, H, T, S, B, B2> as Handler<T, S, B2>>
              <MethodRouter<S, B> as Handler<(), S, B>>
note: required by a bound in `axum::routing::get`

If anyone sees what I'm missing here I'd greatly appreciate it. I've just been staring a this way too long