DependencyScope.COMPILE,
            DependencyScope.PROVIDED);

    PathScope MAIN_RUNTIME =
            pathScope("main-runtime", ProjectScope.MAIN, DependencyScope.COMPILE, DependencyScope.RUNTIME);

    PathScope TEST_COMPILE = pathScope(
            "test-compile",
            ProjectScope.TEST,
            DependencyScope.COMPILE,
            DependencyScope.PROVIDED,
            DependencyScope.TEST_ONLY,

     * @throws IllegalArgumentException if an argument is null or invalid
     *
     * @see DependencyResolver#collect(Session, Project, PathScope)
     * @see DependencyResolver#collect(Session, DependencyCoordinates, PathScope)
     * @see DependencyResolver#collect(Session, Artifact, PathScope)
     */
    @Nonnull
    default DependencyResolverResult collect(@Nonnull DependencyResolverRequest request) {

            this.verbose = verbose;
            return this;
        }

        @Nonnull
        public DependencyResolverRequestBuilder pathScope(@Nullable PathScope pathScope) {
            this.pathScope = pathScope;
            return this;
        }

        /**
         * Filters the types of paths to include in the result.

                .requestType(DependencyResolverRequest.RequestType.COLLECT)
                .pathScope(PathScope.MAIN_COMPILE)
                .build();

        DependencyResolverRequest request2 = builder.session(session)
                .requestType(DependencyResolverRequest.RequestType.COLLECT)
                .pathScope(PathScope.MAIN_COMPILE)
                .build();

        Node root = session.collectDependencies(artifact, PathScope.MAIN_RUNTIME);
        assertNotNull(root);

        DependencyResolverResult result =
                session.getService(DependencyResolver.class).resolve(session, project, PathScope.MAIN_RUNTIME);
        assertNotNull(result);
        List<Dependency> deps = new ArrayList<>(result.getDependencies().keySet());

 * <pre>
 * public class CustomPathScopeProvider implements PathScopeProvider {
 *     public Collection&lt;PathScope&gt; provides() {
 *         return Collections.singleton(pathScope("integration-test",
 *                 ProjectScope.TEST, DependencyScope.TEST));
 *     }
 * }
 * </pre>
 *
 * @see org.apache.maven.api.PathScope
 * @see org.apache.maven.api.spi.ExtensibleEnumProvider
 * @since 4.0.0
 */
@Experimental
@Consumer

 * or resolution request is performed is controlled by the {@link #pathScope()}
 * field, the injected field type and the {@link #requestType()}.
 * <p>
 * If the {@code requestType} is not set explicitly, it will be inferred
 * from the {@code pathScope} and the injected field type. If the type
 * is {@link org.apache.maven.api.Node Node} and {@code pathScope == ""},
 * then the dependencies will be <i>collected</i>.

     * @param scope the {link PathScope} to collect dependencies, must not be {@code null}
     * @return root node of the dependency graph for the given artifact
     *
     * @see org.apache.maven.api.services.DependencyResolver#collect(Session, Artifact, PathScope)
     * @throws org.apache.maven.api.services.DependencyResolverException if the dependency collection failed

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

import org.apache.maven.api.PathScope;

            }
            field.setAccessible(true);
            String pathScope = resolution.getPathScope();
            Object result = null;
            if (pathScope != null && !pathScope.isEmpty()) {
                // resolution
                PathScope ps = sessionV4.getService(PathScopeRegistry.class).require(pathScope);
                DependencyResolverResult res =