*/
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**

import org.apache.maven.api.Dependency;
import org.apache.maven.api.Node;
import org.apache.maven.api.RemoteRepository;
import org.apache.maven.api.annotations.Nonnull;
import org.eclipse.aether.graph.DependencyNode;

class WrapperNode extends AbstractNode {
    protected final Node delegate;
    protected final List<Node> children;

    WrapperNode(Node delegate, List<Node> children) {
        this.delegate = delegate;

        this();
        this.metadata = metadata;
    }

    public MetadataGraphNode addIncident(MetadataGraphNode node) {
        inNodes.add(node);
        return this;
    }

    public MetadataGraphNode addExident(MetadataGraphNode node) {
        exNodes.add(node);
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {

        }
    }

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

    Node getNode(org.eclipse.aether.graph.DependencyNode node);

    Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose);

    @Nonnull
    Artifact getArtifact(@Nonnull org.eclipse.aether.artifact.Artifact artifact);

    @Nonnull

                        delegate.getMojoDescriptor().getPluginDescriptor().getDependencyNode();
                DefaultNode node = new DefaultNode(session, resolverNode, false);
                return Collections.unmodifiableMap(node.stream()
                        .filter(Objects::nonNull)
                        .map(Node::getDependency)
                        .filter(Objects::nonNull)

     */
    @Nonnull
    List<Node> flattenDependencies(@Nonnull Node node, @Nonnull PathScope scope);

    /**
     * Shortcut for {@code getService(DependencyResolver.class).resolve(...).getPaths()}.
     *
     * @param dependencyCoordinate coordinate of the dependency for which to get the paths
     * @return paths to the transitive dependencies of the given dependency
     *

            if (isInScope(resolvedArtifact, nodeArtifact) || "pom".equals(resolvedArtifact.getExtension())) {
                Dependency node = collectStepTrace.getNode();
                trackingData.add(resolvedArtifact.toString());
                indent += "  ";
                trackingData.add(indent + node + " (" + collectStepTrace.getContext() + ")");
                ListIterator<DependencyNode> iter = collectStepTrace

 */
package org.apache.maven.internal.impl;

import java.util.Collection;
import java.util.List;

import org.apache.maven.api.Artifact;
import org.apache.maven.api.DependencyCoordinate;
import org.apache.maven.api.Node;
import org.apache.maven.api.Project;
import org.apache.maven.api.RemoteRepository;
import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Singleton;

    }

    @Test
    void testCollectArtifactDependencies() {
        Artifact artifact =
                session.createArtifact("org.codehaus.plexus", "plexus-container-default", "1.0-alpha-32", "jar");
        Node root = session.collectDependencies(artifact);
        assertNotNull(root);
    }

    @Test
    void testResolveArtifactCoordinateDependencies() {

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

pipeline {
  agent { node { label 'ubuntu' } }
  options {
    durabilityHint('PERFORMANCE_OPTIMIZED')
    buildDiscarder(logRotator(numToKeepStr: '20', artifactNumToKeepStr: '5'))
    timeout(time: 180, unit: 'MINUTES')
  }
  parameters {