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

package org.gradle.internal.logging.events;

import org.gradle.api.logging.LogLevel;

/**
 * Notifies output consumers that the log level has changed. Consumers will not receive any further events at a lesser log level.
 */
public class LogLevelChangeEvent extends OutputEvent {
    private final LogLevel newLogLevel;

        if (Modifier.isPrivate(ctClass.modifiers)) false
        else queryKotlinMetadata(ctClass, false) { metadata ->
            when (metadata) {
                is KotlinClassMetadata.FileFacade -> true
                else -> false
            }
        }

    fun isKotlinInternal(ctClass: CtClass): Boolean =
        if (Modifier.isPrivate(ctClass.modifiers)) false
        else hasKotlinFlag(ctClass, Flag.IS_INTERNAL)

	// For per cluster handlers, they should be registered by the `AppendXXXHandlerForCluster` interface.

	// AppendServiceHandler notifies about changes to the service catalog.
	AppendServiceHandler(f ServiceHandler)

	// AppendWorkloadHandler notifies about changes to workloads. This differs from InstanceHandler,
	// which deals with service instances (the result of a merge of Service and Workload)

import org.gradle.buildinit.plugins.internal.BuildConverter;
import org.gradle.buildinit.plugins.internal.InitSettings;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;
import org.gradle.util.internal.IncubationLogger;
import org.gradle.workers.WorkerExecutor;

 */
package org.gradle.internal.operations;

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

/**
 * A listener that is notified as build operations are executed.
 *
 * Listeners must be registered via {@link BuildOperationListenerManager}, not ListenerManager.
 *

package org.gradle.buildinit.plugins.internal;

import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.Language;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;
import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform;

import java.util.Collections;

import org.gradle.api.file.Directory;
import org.gradle.buildinit.InsecureProtocolOption;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;
import org.gradle.jvm.toolchain.JavaLanguageVersion;

import javax.annotation.Nullable;
import java.util.List;

name: IDE Experience team notifier
run-name: Notify the IDE Experience team about new RCs for manual testing
on:
  push:
    tags:
      - 'v*.*.*-RC1'

permissions: {}

jobs:
  send-slack-notification:
    runs-on: ubuntu-latest
    steps:
      - name: Send Slack notification about new RCs for manual testing
        id: slack
        uses: slackapi/slack-github-action@v1.23.0
        with:
          payload: |
            {

import (
	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
)

// FakeReadyProvider implements a fake ready provider
type FakeReadyProvider struct {
	kubecontainer.SourcesReadyProvider
}

// AllReady notifies caller that the Fake Provider is ready.
func (frp *FakeReadyProvider) AllReady() bool {
	return true
}

// NewFakeReadyProvider creates a FakeReadyProvider object

 * errors while processing the event, it can report these problems via {@link ModelBuildingEvent#problems()}.
 */
public interface ModelBuildingListener {

    /**
     * Notifies the listener that the model has been constructed to the extent where build extensions can be processed.
     *
     * @param event The details about the event.
     */