d.getArtifactId(),
                d.getManagementKey(),
                d);

        validateId(prefix, "groupId", problems, Severity.ERROR, Version.BASE, d.getGroupId(), d.getManagementKey(), d);

        if (!management) {
            validateStringNotEmpty(
                    prefix, "type", problems, Severity.ERROR, Version.BASE, d.getType(), d.getManagementKey(), d);

            if (depMgmt != null) {
                for (Dependency dependency : depMgmt.getDependencies()) {
                    dependencies.put(dependency.getManagementKey(), dependency);
                }
            } else {
                depMgmt = new DependencyManagement();
                target.setDependencyManagement(depMgmt);
            }

    static class CycleInImportsResolver extends BaseModelResolver {
        @Override
        public ModelSource resolveModel(Dependency dependency) throws UnresolvableModelException {
            return switch (dependency.getManagementKey()) {
                case BASE1_ID -> new StringModelSource(BASE1);
                case BASE2_ID -> new StringModelSource(BASE2);
                default -> null;
            };
        }
    }

        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

        for (Dependency dependency : dependencies) {
            normalized.put(dependency.getManagementKey(), dependency);
        }

        if (dependencies.size() != normalized.size()) {
            model.setDependencies(new ArrayList<>(normalized.values()));
        }
    }

    /**
     * DuplicateMerger

                Artifact managedArtifact = createDependencyArtifact(managedDependency, null, pomArtifact);

                managedVersions.put(managedDependency.getManagementKey(), managedArtifact);
            }
        }

        List<ArtifactRepository> aggregatedRepositories =
                aggregateRepositories(request.getRemoteRepositories(), pomRepositories);

        MavenProject project = session.getCurrentProject();

        InputLocation dependencyLocation = null;
        for (Dependency dependency : project.getDependencies()) {
            if (dependency.getManagementKey().equals("org.apache.maven.its:a:jar")) {
                dependencyLocation = dependency.getLocation("version");
            }
        }
        assertNotNull(dependencyLocation, "missing dependency");

                        .setMessage("'dependencyManagement.dependencies.dependency.groupId' for "
                                + dependency.getManagementKey() + " is missing.")
                        .setLocation(dependency.getLocation("")));
                continue;
            }
            if (artifactId == null || artifactId.length() <= 0) {

            target.setReportSets(new ArrayList<>(merged.values()));
        }
    }

    @Override
    protected Object getDependencyKey(Dependency dependency) {
        return dependency.getManagementKey();
    }

    @Override
    protected Object getPluginKey(Plugin plugin) {
        return plugin.getKey();
    }

    @Override

                                repositorySystem.createDependencyArtifact(new org.apache.maven.model.Dependency(d));
                        if (artifact != null) {
                            tmp.put(d.getManagementKey(), artifact);
                        }
                    }
                    return Collections.unmodifiableMap(tmp);
                });
            }
            project.setManagedVersionMap(map);

          <code>
            <![CDATA[
    private volatile String managementKey;

    /**
     * @return the management key as {@code groupId:artifactId:type[:classifier]}
     */
    public String getManagementKey() {
        if (managementKey == null) {
            managementKey = (getGroupId() + ":" + getArtifactId() + ":" + getType()