return
}

// DecodeMsg implements msgp.Decodable
func (z *BatchJobReplicateResourceType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BatchJobReplicateResourceType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable

	return
}

// DecodeMsg implements msgp.Decodable
func (z *scanStatus) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 uint8
		zb0001, err = dc.ReadUint8()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = scanStatus(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z scanStatus) EncodeMsg(en *msgp.Writer) (err error) {

    }

    static interface Details {
        void see(Object... args)
    }

    static class RuleWithoutParams implements Action<Details> {
        @Override
        void execute(Details details) {
            details.see()
        }
    }

    static class RuleWithParams implements Action<Details> {
        private final int x
        private final String str

        RuleWithParams(int x, String str) {

/**
 * Adapts an 'api' library requirement to a default linkage, and then wraps the result so that only headers are provided.
 */
public class ApiRequirementNativeDependencyResolver implements NativeDependencyResolver {
    private final NativeDependencyResolver delegate;

    public ApiRequirementNativeDependencyResolver(NativeDependencyResolver delegate) {
        this.delegate = delegate;
    }

type policyType string

// Policy implements logic for pod container to a memory assignment.
type Policy interface {
	Name() string
	Start(s state.State) error
	// Allocate call is idempotent
	Allocate(s state.State, pod *v1.Pod, container *v1.Container) error
	// RemoveContainer call is idempotent
	RemoveContainer(s state.State, podUID string, containerName string)
	// GetTopologyHints implements the topologymanager.HintProvider Interface

	"k8s.io/kubernetes/pkg/registry/flowcontrol/flowschema"
	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
)

// FlowSchemaStorage implements storage for flow schema.
type FlowSchemaStorage struct {
	FlowSchema *REST
	Status     *StatusREST
}

// REST implements a RESTStorage for flow schema against etcd
type REST struct {
	*genericregistry.Store
}

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

// Package flushwriter implements a wrapper for a writer that flushes on every
// write if that writer implements the io.Flusher interface

 */
public class DefaultExternalComponentGraphResolveState<G extends ExternalComponentGraphResolveMetadata, A extends ExternalComponentResolveMetadata> extends AbstractComponentGraphResolveState<G> implements ExternalComponentGraphResolveState {
    private final ComponentIdGenerator idGenerator;
    private final A legacyMetadata;

    // The resolve state for each configuration of this component

            class PluginA implements $Plugin.name {
                void apply(project) {}
            }
        """
        file("buildSrc/src/main/resources/META-INF/gradle-plugins/a.properties") << "implementation-class=PluginA"

        file("buildSrc/src/main/groovy/PluginB.groovy") << """
            class PluginB implements $Plugin.name {
                void apply(project) {}
            }

import org.objectweb.asm.Type;

public class WithExtensionReferencesExtra implements RequestExtra {
    public final Type ownerType;
    public final String methodName;

    public WithExtensionReferencesExtra(Type ownerType, String methodName) {
        this.ownerType = ownerType;
        this.methodName = methodName;
    }

    public static class ProducedSynthetically implements RequestExtra {
    }