import org.apache.maven.api.annotations.Nonnull;

/**
 * A remote repository that can be used to download or upload artifacts.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface RemoteRepository extends Repository {

    @Nonnull
    String getUrl();

    @Nonnull
    String getProtocol();

    final Session session;
    final RepositoryMerging repositoryMerging;

    List<RemoteRepository> pomRepositories;
    List<RemoteRepository> repositories;
    List<RemoteRepository> externalRepositories;
    Set<String> ids;

    public DefaultModelRepositoryHolder(
            Session session, RepositoryMerging repositoryMerging, List<RemoteRepository> externalRepositories) {
        this.session = session;

    }

    @Override
    public List<org.eclipse.aether.repository.RemoteRepository> toRepositories(List<RemoteRepository> repositories) {
        return repositories == null ? null : map(repositories, this::toRepository);
    }

    @Override
    public org.eclipse.aether.repository.RemoteRepository toRepository(RemoteRepository repository) {
        if (repository instanceof DefaultRemoteRepository) {

        assertTrue(updateCheckManager.isUpdateRequired(a, remoteRepository));

        updateCheckManager.touch(a, remoteRepository, null);

        assertFalse(updateCheckManager.isUpdateRequired(a, remoteRepository));

        assertFalse(file.exists());
        assertNotNull(
                updateCheckManager.readLastUpdated(touchFile, updateCheckManager.getRepositoryKey(remoteRepository)));
    }

    @Test

    }

    @Override
    public RemoteRepository createRemote(String id, String url) {
        return new DefaultRemoteRepository(
                new org.eclipse.aether.repository.RemoteRepository.Builder(id, "default", url).build());
    }

    @Override
    public RemoteRepository createRemote(Repository repository) throws IllegalArgumentException {

    Project getProject(org.apache.maven.project.MavenProject project);

    List<org.eclipse.aether.repository.RemoteRepository> toRepositories(List<RemoteRepository> repositories);

    org.eclipse.aether.repository.RemoteRepository toRepository(RemoteRepository repository);

    org.eclipse.aether.repository.LocalRepository toRepository(LocalRepository repository);

    @Nonnull
    RemoteRepository createRemote(@Nonnull String id, @Nonnull String url);

    @Nonnull
    RemoteRepository createRemote(@Nonnull Repository repository);

    @Nonnull
    List<RemoteRepository> aggregate(
            @Nonnull Session session,
            @Nonnull List<RemoteRepository> dominant,
            @Nonnull List<RemoteRepository> recessive,
            boolean processRecessive);

    }

    private Versioning filterVersionsByRepositoryType(Versioning versioning, RemoteRepository remoteRepository) {
        if (remoteRepository == null) {
            return versioning;
        }
        return versioning.withVersions(versioning.getVersions().stream()
                .filter(version -> remoteRepository
                        .getPolicy(DefaultModelVersionParser.checkSnapshot(version))

import org.eclipse.aether.collection.DependencyCollectionException;
import org.eclipse.aether.graph.DependencyFilter;
import org.eclipse.aether.graph.DependencyNode;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactDescriptorException;
import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
import org.eclipse.aether.resolution.ArtifactDescriptorResult;

    @Nonnull
    Dependency getDependency(@Nonnull org.eclipse.aether.graph.Dependency dependency);

    List<org.eclipse.aether.repository.RemoteRepository> toRepositories(List<RemoteRepository> repositories);

    org.eclipse.aether.repository.RemoteRepository toRepository(RemoteRepository repository);

    org.eclipse.aether.repository.LocalRepository toRepository(LocalRepository repository);