* <p>
     * This order is optimized for both performance and to allow resolvers earlier in the order
     * to mask plugins which would have been found later in the order.
     */
    private void addDefaultResolvers(PluginArtifactRepositories pluginResolveContext, List<PluginResolver> resolvers) {
        resolvers.add(new NoopPluginResolver(pluginRegistry));
        resolvers.add(new CorePluginResolver(documentationRegistry, pluginRegistry));

 */
public interface ModuleComponentRepositoryAccess<T> {
    /**
     * Resolves the given dependency to a list of module versions.
     */
    void listModuleVersions(ModuleDependencyMetadata dependency, BuildableModuleVersionListingResolveResult result);

    /**
     * Resolves the metadata for a module component.
     */

import org.apache.maven.api.annotations.Nonnull;

/**
 * Resolves artifact meta/pseudo versions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface VersionResolver extends Service {

    /**
     * Resolves an artifact's meta version (if any) to a concrete version. For example, resolves "1.0-SNAPSHOT"
     * to "1.0-20090208.132618-23" or "RELEASE"/"LATEST" to "2.0".
     *

import java.util.Collection;

public interface ResolverProviderFactory {
    /**
     * Create any applicable resolvers and add to the given collection.
     */
    void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry);

        if (it.isLowerCase()) it.uppercaseChar() else it
    }
}


class CompositePropertyResolver(private val resolvers: List<RuntimePropertyResolver>) : RuntimePropertyResolver {
    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
        resolvers.forEach {
            val resolution = it.resolvePropertyRead(receiverClass, name)
            if (resolution !is UnresolvedRead)

import java.nio.file.Path;

import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingRequest;

/**
 * Resolves relative paths of a model against a specific base directory.
 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin
     * configuration are not processed.
     *

 * under the License.
 */
package org.apache.maven.model.path;

import java.io.File;
import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

import org.gradle.integtests.tooling.r33.FetchIdeaProject

@TargetGradleVersion(">=5.0")
class ProjectStateLockingCrossVersionTest extends ToolingApiSpecification {
    def "does not emit deprecation warnings when idea model builder resolves a configuration"() {
        singleProjectBuildInRootFolder("root") {
            buildFile << """
                apply plugin: 'java'
            """
        }

        when:
        withConnection {

        resolver
    }

    private void mockRegistry(JavaToolchainResolver... resolvers) {
        def repositories = IntStream.range(0, resolvers.length)
            .mapToObj { i -> mockRepository("resolver" + i, resolvers[i]) }
            .collect(Collectors.toList())

        registry.requestedRepositories() >> repositories
    }

limitations under the License.
*/

package common

import (
	"github.com/google/cel-go/common/types"
	"github.com/google/cel-go/common/types/ref"
)

// TypeResolver resolves a type by a given name.
type TypeResolver interface {
	// Resolve resolves the type by its name, starting with "Object" as its root.
	// The type that the name refers to must be an object.