session, DependencyResolverRequest.RequestType.FLATTEN, project, scope));
    }

    @Nonnull
    default DependencyResolverResult flatten(@Nonnull DependencyResolverRequest request) {
        if (request.getRequestType() != DependencyResolverRequest.RequestType.FLATTEN) {
            throw new IllegalArgumentException("requestType should be FLATTEN when calling flatten()");
        }
        return resolve(request);
    }

		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		m[id] = e
	}
	return m
}

// flatten all children of the root into the root element and return it.
func (d *dataUsageCache) flatten(root dataUsageEntry) dataUsageEntry {
	for id := range root.Children {
		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		root.merge(e)
	}
	root.Children = nil

		path       string
		isNil      bool
		size, objs int
		flatten    bool
		oSizes     sizeHistogram
	}{
		{
			path:    "/",
			size:    363515,
			flatten: true,
			objs:    14,
			oSizes:  sizeHistogram{0: 7, 1: 5, 2: 2},
		},
		{
			path:    "/dir1",
			size:    342210,
			objs:    7,
			flatten: false,
			oSizes:  sizeHistogram{0: 2, 1: 3, 2: 2},
		},
		{

    /**
     * Should upgrade plugins known to fail with Maven 4 to their minimum compatible versions.
     * This includes upgrading plugins like maven-exec-plugin, maven-enforcer-plugin,
     * flatten-maven-plugin, and maven-shade-plugin to versions that work with Maven 4.
     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    @Nonnull

 * followed by <dfn>flattening</dfn> and <dfn>resolution</dfn>.
 * The version selection is done for each dependency during the collection phase.
 * The flatten phase keeps only a single version per ({@code groupId}, {@code artifactId}) pair.
 * The resolution phase actually downloads the dependencies (or artifacts) that have been computed.
 *
 * @since 4.0.0
 */
@Experimental

					// updates-collector goroutine still
					// holds a reference to this.
					wg.Wait()
					continue
				}

				wg.Wait()
				// Flatten for upstream, but save full state.
				var root dataUsageEntry
				if r := cache.root(); r != nil {
					root = cache.flatten(*r)
				}
				select {
				case <-ctx.Done():
					return
				case bucketResults <- dataUsageEntryInfo{
					Name:   cache.Info.Name,

          <type>String</type>
          <description>pathScope used to flatten dependencies</description>
        </field>
        <field>
          <name>requestType</name>
          <required>false</required>
          <version>2.0.0+</version>
          <type>String</type>
          <description>either {@code collect}, {@code flatten}, or {@code resolve}</description>
        </field>
      </fields>
    </class>

            throw IllegalArgumentException("More than one scenario split for test project $key: $projectDurations")
        }
    }
    return durationsPerTestProject
        .mapValues { (_, durations) -> durations.flatten().map { it.scenario } }
}

class EmptyTestProjectBucket(
    private val index: Int,
) : PerformanceTestBucket {
    override fun createPerformanceTestsFor(
        model: CIBuildModel,

    /**
     * Shortcut for {@code getService(DependencyResolver.class).flatten(...)}.
     *
     * @param node node for which to get a flattened list
     * @param scope build path scope (main compile, test compile, etc.) of desired nodes
     * @return flattened list of node with the given build path scope

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface DependencyResolverRequest extends Request<Session> {

    enum RequestType {
        COLLECT,
        FLATTEN,
        RESOLVE
    }

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull
    Optional<Artifact> getRootArtifact();

    @Nonnull