return createArtifact(groupId, artifactId, version, scope, type, null, null);
    }

    @Override
    public Artifact createArtifactWithClassifier(
            String groupId, String artifactId, String version, String type, String classifier) {
        return createArtifact(groupId, artifactId, version, null, type, classifier, null);
    }

    @Override
    public Artifact createDependencyArtifact(

        if (requestBody != null && requestBody.isOneShot()) {
          return null
        }

        if (exchange == null || !exchange.isCoalescedConnection) {
          return null
        }

        exchange.connection.noCoalescedConnections()
        return userResponse.request
      }

      else -> return null
    }
  }

  private fun buildRedirectRequest(

                    it.set(MavenPropertiesLoader.substVars(it.next(), null, null, callback));
                }
            }
            commandLineBuilder.addOption(option);
        }
        for (String arg : cliRequest.commandLine.getArgList()) {
            commandLineBuilder.addArg(MavenPropertiesLoader.substVars(arg, null, null, callback));
        }
        cliRequest.commandLine = commandLineBuilder.build();

        Element profilesElement = root.child(PROFILES).orElse(null);
        if (profilesElement != null) {
            var profileElements = profilesElement.children(PROFILE).toList();
            for (Element profileElement : profileElements) {
                Element profileModulesElement = profileElement.child(MODULES).orElse(null);
                if (profileModulesElement != null) {
                    profileModulesElement.name(SUBPROJECTS);

                errors << "From non-null returning to null returning breaking change"
            } else if (oldNullability == Nullability.NON_NULL && newNullability == Nullability.UNMARKED) {
                errors << "From non-null returning to null-unmarked returning breaking change"

        return this;
    }

    public void addArtifact(Artifact artifact) {
        if (artifacts == null) {
            artifacts = new LinkedHashSet<>();
        }

        artifacts.add(artifact);
    }

    public Set<Artifact> getArtifacts() {
        if (artifacts == null) {
            artifacts = new LinkedHashSet<>();
        }

        return artifacts;
    }

    public void addArtifact(Artifact artifact) {
        if (artifacts == null) {
            artifacts = new LinkedHashSet<>();
        }

        artifacts.add(artifact);
    }

    public Set<Artifact> getArtifacts() {
        return artifacts;
    }

    public void addRequestedArtifact(Artifact artifact) {
        if (requestedArtifacts == null) {
            requestedArtifacts = new LinkedHashSet<>();
        }

    private final boolean lowerBoundInclusive;

    private final ArtifactVersion upperBound;

    private final boolean upperBoundInclusive;

    public static final Restriction EVERYTHING = new Restriction(null, false, null, false);

    public Restriction(
            ArtifactVersion lowerBound,
            boolean lowerBoundInclusive,
            ArtifactVersion upperBound,
            boolean upperBoundInclusive) {

            if (installationToolchainsFileStr != null) {
                installationToolchainsFile = context.installationDirectory
                        .resolve(installationToolchainsFileStr)
                        .normalize();
            }
        }

        request.setInstallationToolchainsFile(
                installationToolchainsFile != null ? installationToolchainsFile.toFile() : null);

        notBlank(groupId, "groupId can neither be null, empty nor blank");
        notBlank(artifactId, "artifactId can neither be null, empty nor blank");
        notBlank(version, "version can neither be null, empty nor blank");

        return groupId + ":" + artifactId + ":" + version;
    }

    private static void notBlank(String str, String message) {
        final int strLen = str != null ? str.length() : 0;
        if (strLen > 0) {