*   <li>Access to the {@link org.apache.maven.api.LocalRepository} and {@link org.apache.maven.api.RemoteRepository} configurations</li>
 *   <li>Access to Maven services through {@link org.apache.maven.api.Session#getService(Class)}</li>
 *   <li>Build configuration and settings</li>
 * </ul>
 *
 * <h3>Dependency management</h3>
 *

missing

In the case of something like Modello where it is common to specify the configuration for all the goals outside the execution block we need to account for creating the right configuration element which includes only those configuration elements for a particular goal that that particular goal understands. We need to walk through the parameters of the Mojo in question and only take the configuration options that apply....

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Annotation used to mark fields that represent configuration properties.
 * This annotation provides metadata about how the configuration property
 * should be handled, including its source, type, default value, and whether it's read-only.
 *
 * @since 4.0.0
 */
@Experimental
@Documented

        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
        configuration.setLocalRepository(getLocalRepository());
        configuration.setRemoteRepositories(Arrays.asList(new ArtifactRepository[] {}));
        configuration.setProcessPlugins(true);
        configuration.setResolveDependencies(true);
        initRepoSession(configuration);

        try {

     * @param config the configuration
     */
    protected AndXServerMessageBlock(final Configuration config) {
        this(config, null);
    }

    /**
     * Constructs an AndX message block with configuration and chained command
     * @param config the configuration
     * @param andx the chained command
     */

    private LinkedHashMap<String, String> mappings;

    public Configuration getRuntimeConfiguration() {
        return runtimeConfiguration;
    }

    public void setRuntimeConfiguration(Configuration runtimeConfiguration) {
        this.runtimeConfiguration = runtimeConfiguration;
    }

    public Configuration getCompileOnlyConfiguration() {
        return compileOnlyConfiguration;
    }

 * @since 3.0
 */
public interface BeanConfigurator {

    /**
     * Performs the specified bean configuration.
     *
     * @param request The configuration request that specifies the bean and the configuration to process, must not be
     *            {@code null}.
     * @throws BeanConfigurationException If the bean configuration could not be successfully processed.
     */

        addSubProject(":rest-api-spec") << """
        configurations { restSpecs\nrestTests }
        artifacts {
          restSpecs(new File(projectDir, "src/main/resources/rest-api-spec/api"))
          restTests(new File(projectDir, "src/yamlRestTest/resources/rest-api-spec/test"))
        }
        """

        addSubProject(":x-pack:plugin") << """
        configurations { restXpackSpecs\nrestXpackTests }
        artifacts {

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class SmbSessionImplTest {

    @Mock
    private CIFSContext cifsContext;
    @Mock
    private Configuration configuration;
    @Mock
    private Credentials credentials;
    @Mock
    private CredentialsInternal credentialsInternal;
    @Mock
    private SmbTransportImpl transport;

    private SmbSessionImpl newSession() {

import org.gradle.api.NamedDomainObjectProvider
import org.gradle.api.artifacts.Configuration
import org.gradle.api.provider.Provider
import java.io.File

fun Configuration.getSingleFileProvider(): Provider<File> {
    val name = this.name
    return incoming.files.elements.map {
        require(it.size <= 1) {
            "Expected at most one file in configuration '$name' but found: $it"
        }
        it.firstOrNull()?.asFile
    }