) {
        super(displayName, parents);
        addServiceValidator(scope, strict);
    }

    /**
     * Validator implements a special type of service ({@link AnnotatedServiceLifecycleHandler})
     * that gets notified about all existing and further service registrations.
     */
    private void addServiceValidator(Class<? extends Scope> scope, boolean strict) {
        add(new ServiceScopeValidator(scope, strict));
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.events;

/**
 * A listener which is notified when operations run as part of the build complete.
 *
 * @since 6.1
 */
public interface OperationCompletionListener {
    /**
     * Called when an operation completes.
     */

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.StatefulListener;
import org.gradle.util.Path;

import javax.annotation.Nullable;

/**
 * A listener that is notified when one project observes the local component metadata of another.
 */
@StatefulListener
@EventScope(Scope.Build.class)
public interface ProjectComponentObservationListener {
    /**

    }

    /**
     * Adds a closure to be notified before a test is executed. A {@link TestDescriptor} instance is passed to the closure as a parameter.
     *
     * @param closure The closure to call.
     */
    public void beforeTest(Closure closure) {
        addDispatchAsTestListener("beforeTest", closure);
    }

    /**

public interface AnnotatedServiceLifecycleHandler {
    List<Class<? extends Annotation>> getAnnotations();

    /**
     * When not null, all services are considered to have the implicit annotation
     * and the handler should be notified about all registrations.
     */
    @Nullable
    Class<? extends Annotation> getImplicitAnnotation();

    /**
     * Called when a service with the given annotation is registered.
     */

    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must cancel the returned event source when it is no longer in use.
     */
    fun newEventSource(
      request: Request,
      listener: EventSourceListener,
    ): EventSource
  }

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.StatefulListener;

/**
 * A listener that is notified when a root build is started and completed. No more than one root build may run at a given time.
 *
 * A root build may contain zero or more nested builds, such as `buildSrc` or included builds.
 *

import org.gradle.api.Task;
import org.gradle.internal.DeprecatedInGradleScope;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

/**
 * <p>A {@code TaskActionListener} is notified of the actions that a task performs.</p>
 *
 * @deprecated This type is not supported when configuration caching is enabled.
 */
@EventScope(Scope.Build.class)
@Deprecated
@DeprecatedInGradleScope

import org.gradle.internal.exceptions.DefaultMultiCauseException;

import javax.annotation.Nullable;

/**
 * A {@code ListenerNotificationException} is thrown when a listener cannot be notified of an event.
 */
@Contextual
public class ListenerNotificationException extends DefaultMultiCauseException {
    private final MethodInvocation event;

     */
    void onEvent(Object event);

    /**
     * Returns the type of operations that the listener wants to subscribe to.
     *
     * @return the type of operations to be notified about
     */
    List<String> getSubscribedOperations();