*
     * @return an {@link Optional} containing the list of goals, or empty if not specified
     */
    @Nonnull
    Optional<List<String>> goals();

    /**
     * Returns the target POM model version for upgrades.
     * Supported values include "4.0.0" and "4.1.0".
     *
     * @return an {@link Optional} containing the model version, or empty if not specified
     */
    @Nonnull

    }

    @Override
    public Optional<Project> getProject() {
        return Optional.ofNullable(session.getProject(delegate.getProject()));
    }

    @Override
    public Optional<MojoExecution> getMojoExecution() {
        return Optional.ofNullable(delegate.getMojoExecution()).map(me -> new DefaultMojoExecution(session, me));
    }

    @Override
    public Optional<Exception> getException() {

        return of(active, optional, true);
    }

    static ActivationSettings of(final boolean active, final boolean optional, final boolean recursive) {
        return new ActivationSettings(active, optional, recursive);
    }

    static ActivationSettings activated() {
        return new ActivationSettings(true, false, true);
    }

    static ActivationSettings activatedOpt() {

     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    Optional<Boolean> force();

    /**
     * Should imply "yes" to all questions.
     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    Optional<Boolean> yes();

    /**

        when(options.all()).thenReturn(Optional.ofNullable(all));
        when(options.infer()).thenReturn(Optional.ofNullable(infer));
        when(options.model()).thenReturn(Optional.ofNullable(model));
        when(options.plugins()).thenReturn(Optional.ofNullable(plugins));
        when(options.modelVersion()).thenReturn(Optional.ofNullable(modelVersion));
        return options;
    }

    /**

     */
    @Nonnull
    Optional<Path> rootDirectory();

    /**
     * Returns the input stream for the Maven execution, if running in embedded mode.
     *
     * @return an {@link Optional} containing the input stream, or empty if not applicable
     */
    @Nonnull
    default Optional<InputStream> stdIn() {
        return Optional.ofNullable(parserRequest().stdIn());
    }

    /**

    private ProtoLookup(Map<Class<?>, Object> components) {
        this.components = components;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        Optional<T> optional = lookupOptional(type);
        if (optional.isPresent()) {
            return optional.get();
        } else {
            throw new LookupException("No mapping for key: " + type.getName());
        }
    }

    @Override

        response_model: Any = Default(None),
        status_code: Optional[int] = None,
        tags: Optional[list[Union[str, Enum]]] = None,
        dependencies: Optional[Sequence[params.Depends]] = None,
        summary: Optional[str] = None,
        description: Optional[str] = None,
        response_description: str = "Successful Response",
        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,

    p: Optional[str] = None


@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[QueryModelOptionalStr, Query()]):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": False,
            "schema": {

    return {"p": p}


class BodyModelOptionalStr(BaseModel):
    p: Optional[str] = None


@app.post("/model-optional-str", operation_id="model_optional_str")
async def read_model_optional_str(p: BodyModelOptionalStr):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
    openapi = app.openapi()