this(session, project, executionPlan, null);
    }

    public ProjectExecutionEvent(MavenSession session, MavenProject project, Throwable cause) {
        this(session, project, null, cause);
    }

    public ProjectExecutionEvent(
            MavenSession session, MavenProject project, List<MojoExecution> executionPlan, Throwable cause) {
        this.session = session;
        this.project = project;

    private static final ThreadLocal<AtomicReference<MavenSession>> SESSION = new InheritableThreadLocal<>();

    @Override
    public void setSession(MavenSession session) {
        AtomicReference<MavenSession> reference = DefaultLegacySupport.SESSION.get();
        if (reference != null) {
            reference.set(null);
        }

        if (session == null && reference != null) {

            @Nonnull Session session, @Nonnull ArtifactCoordinates artifactCoordinates) {
        return build(session, artifactCoordinates, null, null);
    }

    /**
     * Creates a version range resolver request.
     *
     * @param session the session to use, must not be {@code null}
     * @param artifactCoordinates the artifact coordinates whose version range should be resolved, must not be {@code null}

    }

    @NotThreadSafe
    class VersionResolverRequestBuilder {
        Session session;
        RequestTrace trace;
        ArtifactCoordinates artifactCoordinates;
        List<RemoteRepository> repositories;

        public VersionResolverRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

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()

    class ArtifactResolverRequestBuilder {
        Session session;
        RequestTrace trace;
        Collection<? extends ArtifactCoordinates> coordinates;
        List<RemoteRepository> repositories;

        ArtifactResolverRequestBuilder() {}

        @Nonnull
        public ArtifactResolverRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

        @Nonnull

    void testGettersAndState() {
        SmbSessionImpl session = newSession();

        // Basic getters
        assertSame(configuration, session.getConfig(), "getConfig delegates to transportContext");
        assertEquals("EXAMPLE", session.getTargetDomain());
        assertEquals("server.example", session.getTargetHost());
        assertTrue(session.isInUse(), "New session starts in-use (usageCount=1)");

        session.withLocalRepositories(new LocalRepository(new File("target/local-repo"), "simple"));
        session.setTransferListener(new ConsoleTransferListener());
        session.setRepositoryListener(new ConsoleRepositoryListener());

        return session.build();
    }

    public static RemoteRepository newTestRepository() throws MalformedURLException {
        return new RemoteRepository.Builder(
                        "repo",

import org.eclipse.aether.util.ConfigUtils;
import org.eclipse.aether.version.InvalidVersionSpecificationException;
import org.eclipse.aether.version.Version;
import org.eclipse.aether.version.VersionConstraint;
import org.eclipse.aether.version.VersionRange;
import org.eclipse.aether.version.VersionScheme;

/**
 * @deprecated since 4.0.0, use {@code maven-api-impl} jar instead/
 */
@Named

    @Test
    void testRequestTraceIntegration() {
        Session session = mock(Session.class);
        RequestTrace trace = new RequestTrace("test-context", null, "test-data");

        ArtifactInstallerRequest request =
                ArtifactInstallerRequest.builder().session(session).trace(trace).build();

        assertEquals(trace, request.getTrace());
        assertEquals(session, request.getSession());
    }

    @Test