*
     * @param settings The settings to decrypt, must not be {@code null}.
     */
    public DefaultSettingsDecryptionRequest(Settings settings) {
        setServers(settings.getServers());
        setProxies(settings.getProxies());
    }

    /**
     * Creates a new request to decrypt the specified server.
     *
     * @param server The server to decrypt, must not be {@code null}.

     *
     * @return The decrypted server or {@code null}.
     */
    Server getServer();

    /**
     * Gets the decrypted servers.
     *
     * @return The decrypted server, can be empty but never {@code null}.
     */
    List<Server> getServers();

    /**

            dominant.setLocalRepository(recessive.getLocalRepository());
        }

        shallowMergeById(dominant.getMirrors(), recessive.getMirrors(), recessiveSourceLevel);
        shallowMergeById(dominant.getServers(), recessive.getServers(), recessiveSourceLevel);
        shallowMergeById(dominant.getProxies(), recessive.getProxies(), recessiveSourceLevel);
        shallowMergeById(dominant.getProfiles(), recessive.getProfiles(), recessiveSourceLevel);

     *
     * @return The servers to decrypt, never {@code null}.
     */
    List<Server> getServers();

    /**
     * Sets the servers whose passwords should be decrypted.
     *
     * @param servers The servers to decrypt, may be {@code null}.
     * @return This request, never {@code null}.
     */
    SettingsDecryptionRequest setServers(List<Server> servers);

    /**
     * Gets the proxies whose passwords should be decrypted.

        Objects.requireNonNull(server, "server cannot be null");

        for (Server p : getServers()) {
            if (p.getId() != null && p.getId().equals(server.getId())) {
                return this;
            }
        }

        getServers().add(server);

        return this;
    }

    @Override
    public List<Mirror> getMirrors() {

        this.problems = (problems != null) ? problems : new ArrayList<>();
    }

    @Override
    public Server getServer() {
        return servers.isEmpty() ? null : servers.get(0);
    }

    @Override
    public List<Server> getServers() {
        return servers;
    }

    @Override
    public Proxy getProxy() {
        return proxies.isEmpty() ? null : proxies.get(0);
    }

        List<SettingsProblem> problems = new ArrayList<>();

        List<Server> servers = new ArrayList<>();

        for (Server server : request.getServers()) {
            server = server.clone();

            String password = server.getPassword();
            if (securityDispatcher.isAnyEncryptedString(password)) {
                try {

    }

    private void injectSession2(ArtifactResolutionRequest request, MavenSession session) {
        injectSession1(request, session);

        if (session != null) {
            request.setServers(session.getRequest().getServers());
            request.setMirrors(session.getRequest().getMirrors());
            request.setProxies(session.getRequest().getProxies());
        }
    }

    @Override

        request.setPluginGroups(settings.getPluginGroups());

        request.setLocalRepositoryPath(settings.getLocalRepository());

        for (Server server : settings.getServers()) {
            request.addServer(server);
        }

        //  <proxies>
        //    <proxy>
        //      <active>true</active>
        //      <protocol>http</protocol>

        if (session != null && id != null) {
            MavenExecutionRequest request = session.getRequest();

            if (request != null) {
                List<Server> servers = request.getServers();

                if (servers != null) {
                    for (Server server : servers) {
                        if (id.equalsIgnoreCase(server.getId())) {
                            SettingsDecryptionResult result =