.addValue(Collections.emptyMap())
            .addValue(null)
            .add(SHORT_NAME, Optional.of("1"))
            .add(LONG_NAME, Optional.of("1"))
            .add(SHORT_NAME, Optional.absent())
            .add(LONG_NAME, Optional.absent())
            .add(SHORT_NAME, Optional.of("2"))
            .add(SHORT_NAME, Optional.absent())
            .addValue(null)
            .add(SHORT_NAME, new int[] {1})

                @Nonnull
                @Override
                public Optional<Path> getPomFile() {
                    return Optional.ofNullable(res.getPomFile()).map(File::toPath);
                }

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

package org.apache.maven.cling.invoker.cisupport;

import java.util.Optional;

import org.apache.maven.api.cli.cisupport.CIInfo;

/**
 * Circle CI support.
 */
public class CircleCIDetector implements CIDetector {
    public static final String NAME = "CircleCI";

    private static final String CIRCLECI = "CIRCLECI";

    @Override
    public Optional<CIInfo> detectCI() {
        String ciEnv = System.getenv(CIRCLECI);

package org.apache.maven.cling.invoker.cisupport;

import java.util.Optional;

import org.apache.maven.api.cli.cisupport.CIInfo;

/**
 * Jenkins CI support.
 */
public class JenkinsCIDetector implements CIDetector {
    public static final String NAME = "Jenkins";

    private static final String WORKSPACE = "WORKSPACE";

    @Override
    public Optional<CIInfo> detectCI() {
        String workspace = System.getenv(WORKSPACE);

     * @param active Should the project be activated?
     * @param optional Can the build continue if the project does not exist?
     */
    public void addProjectActivation(String selector, boolean active, boolean optional) {
        final ActivationSettings settings = ActivationSettings.of(active, optional);
        this.activations.add(new ProjectActivationSettings(selector, settings));
    }

    public static final String NAME = "Generic";

    private static final String CI = "CI";

    @Override
    public Optional<CIInfo> detectCI() {
        String ciEnv = System.getenv(CI);
        if (ciEnv != null && !"false".equals(ciEnv)) {
            return Optional.of(new CIInfo() {
                @Override
                public String name() {
                    return NAME;
                }

		config.HelpKV{
			Key:         target.WebhookAuthToken,
			Description: "opaque string or JWT authorization token",
			Optional:    true,
			Type:        "string",
			Sensitive:   true,
			Secret:      true,
		},
		config.HelpKV{
			Key:         config.Comment,
			Description: config.DefaultComment,
			Optional:    true,
			Type:        "sentence",
		},
		config.HelpKV{
			Key:         target.WebhookClientCert,

        response_model: Any = Default(None),
        status_code: Optional[int] = None,
        tags: Optional[list[Union[str, Enum]]] = None,
        dependencies: Optional[Sequence[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,

            }

            @Nonnull
            @Override
            public Optional<Path> getPath() {
                return Optional.ofNullable(path);
            }

            @Nonnull
            @Override
            public Optional<Source> getSource() {
                return Optional.ofNullable(source);
            }

            @Override

        return versionRange.isSelectedVersionKnown(this);
    }

    @Override
    public void setOptional(boolean optional) {
        this.optional = optional;
    }