return null;
    }

    @Override
    public MojoDescriptor getMojoDescriptor(
            Plugin plugin, String goal, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return MojoExecutorStub.createMojoDescriptor(plugin);
    }

    @Override
    public ClassRealm getPluginRealm(MavenSession session, PluginDescriptor pluginDescriptor) {

    /**
     * Gets the currently active session.
     *
     * @return The currently active session or {@code null} if none.
     */
    MavenSession getSession();

    /**
     * Gets the currently active repository session.
     *
     * @return The currently active repository session or {@code null} if none.
     */
    RepositorySystemSession getRepositorySession();

    }

    private RepositorySystemSession createMockSession(Map<String, Object> configProperties) {
        RepositorySystemSession session = Mockito.mock(RepositorySystemSession.class);
        when(session.getConfigProperties()).thenReturn(configProperties);
        return session;
    }

    private DeployRequest createDeployRequestWithConsumerPom() {
        DeployRequest request = new DeployRequest();

        RepositorySystemSession session = rss(c);

        ArtifactRepository repository = repositorySystem.buildArtifactRepository(repo);

        if (session != null) {
            repositorySystem.injectMirror(session, Arrays.asList(repository));
            repositorySystem.injectProxy(session, Arrays.asList(repository));
            repositorySystem.injectAuthentication(session, Arrays.asList(repository));
        }

            }

            if (mirrors) {
                repositorySystem.injectMirror(session, repositories);
            }

            repositorySystem.injectProxy(session, repositories);

            repositorySystem.injectAuthentication(session, repositories);
        }

        return repository;
    }

        // VersionRangeResult resolveVersionRange( RepositorySystemSession session, VersionRangeRequest request )
        //                throws VersionRangeResolutionException;

    }

    @Test
    void testResolveVersion() throws Exception {
        // VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
        //                throws VersionResolutionException;
    }

    /**
     * @param session the repository session
     * @param repository the repository to deploy to
     * @param artifacts the collection of artifacts to deploy
     * @throws ArtifactDeployerException if the deployment failed
     * @throws IllegalArgumentException if an argument is {@code null} or invalid
     */
    default void deploy(
            @Nonnull Session session,

     * the artifact would eventually be stored.
     *
     * @param session The session to use, must not be {@code null}.
     * @param artifact The artifact for which to determine the path, must not be {@code null}.
     * @return The path, resolved against the local repository's base directory.
     */
    @Nonnull
    Path getPathForLocalArtifact(@Nonnull Session session, @Nonnull LocalRepository local, @Nonnull Artifact artifact);

    /**

def get_session():
    with Session(engine) as session:
        yield session


app = FastAPI()


@app.on_event("startup")
def on_startup():
    create_db_and_tables()


@app.post("/heroes/", response_model=HeroPublic)
def create_hero(hero: HeroCreate, session: Session = Depends(get_session)):
    db_hero = Hero.model_validate(hero)
    session.add(db_hero)
    session.commit()

     * @param project         The project whose dependencies should be resolved, must not be {@code null}.
     * @param scopesToResolve The dependency scopes that should be resolved, may be {@code null}.
     * @param session         The current build session, must not be {@code null}.
     * @return The transitive dependencies of the specified project that match the requested scopes, never {@code null}.
     * @throws ArtifactResolutionException in case of resolution issue