ModuleIdentifier replacedBy = replacement == null ? null : replacement.getTarget();
        return potentialConflict(conflicts.newElement(candidate.getId(), candidate.getVersions(), replacedBy));
    }

    /**
     * Informs if there are any batched up conflicts.
     */
    @Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    /**

        Property<String> dokkaVersionOverride = extension.getKotlinDslReference().getDokkaVersionOverride();
        Property<String> defaultDokkaVersion = getDokkatooExtension(project).getVersions().getJetbrainsDokka();
        defaultDokkaVersion.set(dokkaVersionOverride.convention(defaultDokkaVersion.get()));
    }

    /**

         *
         * @return The snapshot timestamped version
         */
        public String getVersion() {
            return snapshotMetadata.getVersioning().getSnapshotVersions().get(0).getVersion();
        }
    }

    /**
     * Publishes artifacts for a single Maven module.
     */
    private static class ModuleArtifactPublisher {

                        result.getVersion(),
                        request.getPom());
            }
        } else {
            logger.debug(
                    "Reusing cached resolved plugin version for {}:{} to {} from POM {}",
                    request.getGroupId(),
                    request.getArtifactId(),
                    result.getVersion(),
                    request.getPom());
        }

                // Keep the project selected
                newSelectedIsProject = true;
            }
        }
        Version newVersion = versionParser.transform(newSelected.getVersion());
        Version currentVersion = versionParser.transform(selected.getVersion());
        return !newSelectedIsProject && versionComparator.compare(newVersion, currentVersion) <= 0;
    }

    void maybeCreateVirtualMetadata(ResolveState resolveState) {

            switch (result.getState()) {
                case Listed:
                    ModuleIdentifier moduleId = dependency.getSelector().getModuleIdentifier();
                    Set<String> versionList = result.getVersions();
                    Set<ModuleVersionIdentifier> versions = versionList
                        .stream()
                        .map(original -> DefaultModuleVersionIdentifier.newId(moduleId, original))

        return getService(VersionResolver.class).resolve(this, artifact).getVersion();
    }

    @Override
    public List<Version> resolveVersionRange(ArtifactCoordinate artifact) {
        return getService(VersionRangeResolver.class).resolve(this, artifact).getVersions();
    }

    @Override
    public Type requireType(String id) {

                            forcedEdges.add(incomingEdge);
                            if (currentVersion == null) {
                                currentVersion = mcs.getVersion();
                            } else {
                                if (!currentVersion.equals(mcs.getVersion())) {
                                    hasMultipleVersions = true;
                                }
                            }
                        }

            }

            String taskPath = projectPath.append(Path.path("dependencyInsight")).getPath();

            ModuleVersionIdentifier identifier = conflicts.iterator().next().getVersions().get(0);
            String dependencyNotation = identifier.getGroup() + ":" + identifier.getName();

            return Collections.singletonList(String.format(

Austin Anderson <******@****.***> 1704849822 -0800