| <<<classpath-jar>>> * | <<<tests>>>   | <<<jar>>>  | java      | classes               |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<fatjar>>> *        | <<<tests>>>   | <<<jar>>>  | java      | classes               |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

     * The fat-JAR is a self-contained JAR and its transitive dependencies will not be resolved, if any.
     * This type is new in Maven 4.
     */
    String FATJAR = "fatjar";

    /**
     * Artifact type name for a JAR file to unconditionally place on the class path.
     * If the JAR is modular, its module information are ignored.
     * This type is new in Maven 4.
     */

                new DefaultType(Type.CLASSPATH_JAR, Language.JAVA_FAMILY, "jar", null, false, JavaPathType.CLASSES),
                new DefaultType(Type.FATJAR, Language.JAVA_FAMILY, "jar", null, true, JavaPathType.CLASSES),
                new DefaultType(
                        Type.PROCESSOR,
                        Language.JAVA_FAMILY,
                        "jar",

Si todo está funcionando, o después de hacer los cambios necesarios, y todos tus tests pasan, entonces puedes fijar tu `fastapi` a esa nueva versión más reciente.

## Sobre Starlette { #about-starlette }

No deberías fijar la versión de `starlette`.

Diferentes versiones de **FastAPI** utilizarán una versión más reciente específica de Starlette.

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);
    }

    @Override
    public void fatal(final String message, final Throwable t) {
        logger.fatal(message, t);
    }

    @Override
    public boolean isErrorEnabled() {
        return logger.isErrorEnabled();
    }

 */
package org.codelibs.core.log;

/**
 * Adapter for using any logging framework.
 *
 * @author koichik
 */
interface LoggerAdapter {

    boolean isFatalEnabled();

    void fatal(String message);

    void fatal(String message, Throwable t);

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    public void testError() throws Exception {
        logger.error("error");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFatal() throws Exception {
        logger.fatal("fatal");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testLog() throws Exception {
        logger.log("ILOGTEST0001");
    }

    /**
     * @throws Exception
     */

Essas faturas terão um `id`, `title` (opcional), `customer` e `total`.

O usuário da sua API (um desenvolvedor externo) criará uma fatura na sua API com um request POST.

Então sua API irá (vamos imaginar):

* Enviar a fatura para algum cliente do desenvolvedor externo.
* Coletar o dinheiro.
* Enviar a notificação de volta para o usuário da API (o desenvolvedor externo).

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override
    public void fatal(final String message) {
        logger.logp(Level.SEVERE, sourceClass, null, message);
    }

    @Override
    public void fatal(final String message, final Throwable t) {
        logger.logp(Level.SEVERE, sourceClass, null, message, t);
    }

    @Override

            }
        } catch (ToolchainsParseException e) {
            problems.add(
                    Problem.Severity.FATAL,
                    "Non-parseable toolchains " + toolchainsSource.getLocation() + ": " + e.getMessage(),
                    e.getLineNumber(),
                    e.getColumnNumber(),
                    e);