import org.jetbrains.kotlin.load.kotlin.PackagePartProvider

public abstract class KotlinPackagePartProviderFactory : KotlinPlatformComponent {
    /**
     * Create a [PackagePartProvider] for a given scope. [PackagePartProvider] is responsible for searching sub packages in a library.
     */
    public abstract fun createPackagePartProvider(scope: GlobalSearchScope): PackagePartProvider

    public companion object {

 */
@Incubating
public interface BuildableComponentSpec extends Buildable, ComponentSpec {
    /**
     * Returns the task responsible for building this component.
     */
    @Nullable
    Task getBuildTask();

    /**
     * Specifies the task responsible for building this component.
     */
    void setBuildTask(@Nullable Task buildTask);

    /**

     * @param type The concrete type of element in the container (must implement {@link Named})
     * @param instantiator The instantiator to use to create any other collections based on this one
     * @param factory The factory responsible for creating new instances on demand
     * @param collectionCallbackActionDecorator the decorator for collection callback action execution
     */

 */
@Incubating
public interface CheckableComponentSpec extends ComponentSpec {

    /**
     * Returns the task responsible for checking this component.
     */
    @Nullable
    Task getCheckTask();

    /**
     * Specifies the task responsible for checking this component.
     */
    void setCheckTask(@Nullable Task checkTask);

    /**

import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.concurrent.ThreadSafe;

/**
 * Responsible for running the work of a build tree, packaged as zero or more {@link ExecutionPlan} instances.
 */
@ServiceScope(Scope.BuildTree.class)
@ThreadSafe
public interface PlanExecutor {
    /**

     * reference. If the cached data is mutable, i.e. could be modified after being put into the cache, the caller is
     * responsible for creating a copy of the original data and store the copy in the cache.
     *
     * @param request The repository request from which this cache was retrieved, must not be {@code null}.

import org.gradle.internal.action.InstantiatingAction;

/**
 * A caching rule executor allows caching the result of processing a rule. A rule is represented by a
 * {@link InstantiatingAction<DETAILS> instantiating action}, which is responsible for instantiating
 * and configuring a rule. From a user point of view, a rule works on a {@link DETAILS} instance,
 * which is often, but not necessarily, a builder. A {@link DETAILS} can mutate an existing object,

     * @return The input stream. Never returns null. The caller is responsible for closing this stream.
     */
    InputStream open();

    /**
     * Copies the content of this file to an output stream. Generally, calling this method is more performant than
     * calling {@code new FileInputStream(getFile())}.
     *
     * @param output The output stream to write to. The caller is responsible for closing this stream.
     */

	IsUnderPIDPressure() bool
}

// DiskInfoProvider is responsible for informing the manager how disk is configured.
type DiskInfoProvider interface {
	// HasDedicatedImageFs returns true if the imagefs is on a separate device from the rootfs.
	HasDedicatedImageFs(ctx context.Context) (bool, error)
}

// ImageGC is responsible for performing garbage collection of unused images.
type ImageGC interface {

    - **Pilot** - Responsible for configuring the proxies at runtime.

    - **Citadel** - Responsible for certificate issuance and rotation.

    - **Galley** - Responsible for validating, ingesting, aggregating, transforming and distributing config within Istio.