request.setInteractiveMode(settings.isInteractiveMode());

        request.setPluginGroups(settings.getPluginGroups());

        request.setLocalRepositoryPath(settings.getLocalRepository());

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

        //  <proxies>
        //    <proxy>
        //      <active>true</active>

                    PluginNotFoundException, PluginVersionNotFoundException {
        return verifyPlugin(plugin, project, session.getSettings(), session.getLocalRepository());
    }

    public PluginDescriptor loadPluginFully(Plugin plugin, MavenProject project, MavenSession session)

                .setResolveTransitively(true)
                .setCollectionFilter(collectionScopeFilter)
                .setResolutionFilter(resolutionScopeFilter)
                .setLocalRepository(session.getLocalRepository())
                .setOffline(session.isOffline())
                .setForceUpdate(session.getRequest().isUpdateSnapshots());
        request.setServers(session.getRequest().getServers());

            ArtifactRepository repository = metadataResult.getRequest().getRepository();
            if (repository == null) {
                repository = session.getLocalRepository();
            }

            Versioning versioning = readVersions(session, trace, metadataResult.getMetadata(), repository, result);

            versioning = filterVersionsByRepositoryType(

        request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0);
        request.setResolveDependencies(false);

        request.setLocalRepository(configuration.getLocalRepository());
        request.setBuildStartTime(configuration.getBuildStartTime());
        request.setUserProperties(configuration.getUserProperties());
        request.setSystemProperties(configuration.getExecutionProperties());

            return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
        }

        public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
                throws ArtifactMetadataRetrievalException {
            return retrieveAvailableVersions(
                    request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
        }
    }

                supplier.getDependencyManager(Boolean.parseBoolean(resolverDependencyManagerTransitivity)));

        ArrayList<Path> paths = new ArrayList<>();
        paths.add(Paths.get(request.getLocalRepository().getBasedir()));
        String localRepoTail = mergedProps.get(Constants.MAVEN_REPO_LOCAL_TAIL);
        if (localRepoTail != null) {
            Arrays.stream(localRepoTail.split(","))

        }
        if (userDefinedLocalRepo != null) {
            return context.cwdResolver.apply(userDefinedLocalRepo);
        }
        // settings
        userDefinedLocalRepo = context.effectiveSettings.getLocalRepository();
        if (userDefinedLocalRepo != null && !userDefinedLocalRepo.isEmpty()) {
            return context.userResolver.apply(userDefinedLocalRepo);
        }
        // defaults

    }

    public void resolve(RepositoryMetadata metadata, RepositoryRequest request)
            throws RepositoryMetadataResolutionException {
        ArtifactRepository localRepo = request.getLocalRepository();
        List<ArtifactRepository> remoteRepositories = request.getRemoteRepositories();

        if (!request.isOffline()) {
            Date localCopyLastModified = null;

    MavenExecutionRequest setLocalRepositoryPath(File localRepository);

    File getLocalRepositoryPath();

    MavenExecutionRequest setLocalRepository(ArtifactRepository repository);

    ArtifactRepository getLocalRepository();

    // Interactive
    MavenExecutionRequest setInteractiveMode(boolean interactive);

    boolean isInteractiveMode();

    // Offline
    MavenExecutionRequest setOffline(boolean offline);