this.asGraph = asGraph;
        return this;
    }

    public MetadataResolutionRequest setScope(String scope) {
        this.scope = scope;
        return this;
    }

    public String getScope() {
        return scope;
    }

			<version>2.2</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mockito</groupId>
			<artifactId>mockito-core</artifactId>
			<version>5.11.0</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.testcontainers</groupId>
			<artifactId>testcontainers</artifactId>
			<version>1.21.3</version>
			<scope>test</scope>
		</dependency>
		<dependency>

            @Nonnull Session session, @Nonnull DependencyCoordinates root, @Nonnull PathScope scope) {
        return collect(
                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.COLLECT, root, scope));
    }

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph for the given path scope.

        artifact = new DefaultArtifact(groupId, artifactId, versionRange, scope, type, classifier, artifactHandler);

        snapshotVersionRange = VersionRange.createFromVersion(snapshotResolvedVersion);
        snapshotArtifact = new DefaultArtifact(
                groupId, artifactId, snapshotVersionRange, scope, type, classifier, artifactHandler);
    }

    @Test

     * @param scope the NetBIOS scope identifier (uses default if null or empty)
     */
    public Name(String name, final int hexCode, final String scope) {
        if (name.length() > 15) {
            name = name.substring(0, 15);
        }
        this.name = name.toUpperCase();
        this.hexCode = hexCode;
        this.scope = scope != null && scope.length() > 0 ? scope : DEFAULT_SCOPE;

    // ------------------------------------------------------------------------
    public MetadataTreeNode(ArtifactMetadata md, MetadataTreeNode parent, boolean resolved, ArtifactScopeEnum scope) {
        if (md != null) {
            md.setArtifactScope(ArtifactScopeEnum.checkScope(scope));
            md.setResolved(resolved);
        }

        this.md = md;
        this.parent = parent;
    }

     * for a description of <code>type</code>
     * and <code>scope</code>.
     *
     * @param host
     *            hostname to lookup all addresses for
     * @param type
     *            the hexcode of the name
     * @param scope
     *            the scope of the name
     * @return resolved addresses
     * @throws java.net.UnknownHostException

The spec also states that the `username` and `password` must be sent as form data (so, no JSON here).

### `scope` { #scope }

The spec also says that the client can send another form field "`scope`".

The form field name is `scope` (in singular), but it is actually a long string with "scopes" separated by spaces.

Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

     * between any two nodes, if multiple exists. Uses scope relationships, defined
     * in <code>ArtifactScopeEnum</code>
     *
     * @param graph the "dirty" graph to be simplified via conflict resolution
     * @param scope scope for which the graph should be resolved
     *
     * @return resulting "clean" graph for the specified scope
     *
     * @since 3.0
     */

        return scope;
    }

    public void setScope(ArtifactScopeEnum scope) {
        this.scope = scope;
    }

    // -------------------------------------------------------------------------------------------
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(256);
        sb.append("[scope=").append(scope.getScope());
        if (classpath != null) {