import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerRegistry;
import org.gradle.model.internal.type.ModelType;

import static org.gradle.model.internal.core.NodeInitializerContext.forType;

public class ManagedChildNodeCreatorStrategy<T> implements ChildNodeInitializerStrategy<T> {

    private final NodeInitializerRegistry nodeInitializerRegistry;

}

var xxx_messageInfo_EndpointSliceList proto.InternalMessageInfo

func (m *ForZone) Reset()      { *m = ForZone{} }
func (*ForZone) ProtoMessage() {}
func (*ForZone) Descriptor() ([]byte, []int) {
	return fileDescriptor_6555bad15de200e0, []int{6}
}
func (m *ForZone) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ForZone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]

  - ${validationProblem}"""
        }
        _ * work.validate(_ as WorkValidationContext) >> { WorkValidationContext validationContext ->
            validationContext.forType(JobType, true).visitTypeProblem {
                it
                    .withAnnotationType(Object)
                    .id("test-problem", "Validation error", GradleCoreProblemGroup.validation())

// CHECK-NEXT:    [[HANDLE:%.*]] = "tf.VarHandleOp"()
// CHECK-NEXT:    [[ARRAYKEY:%.*]], [[FURTURE:%.*]] = "tf_mlrt.tf_ifrt_load_variable"([[HANDLE]])
// CHECK-SAME:       <{used_by_host = true}> : (tensor<!tf_type.resource<tensor<3x1xf32>>>) -> (tensor<!tf_type.string>, !mlrt.future)
// CHECK-NEXT:    [[TENSOR:%.*]] = "tf_mlrt.tf_await"([[FURTURE]]) : (!mlrt.future) -> tensor<3x1xf32>

import org.gradle.model.internal.type.ModelType;

import static org.gradle.model.internal.core.DefaultNodeInitializerRegistry.DEFAULT_REFERENCE;
import static org.gradle.model.internal.core.NodeInitializerContext.forType;

@ThreadSafe
public class TransformedModelDslBacking {
    private final ModelRegistry modelRegistry;
    private final ClosureBackedRuleFactory ruleFactory;

							ForZones: []discovery.ForZone{{Name: "zone-a"}},
						},
					},
					{
						Hints: &discovery.EndpointHints{
							ForZones: []discovery.ForZone{{Name: "zone-b"}},
						},
					},
				},
			},
			expectedEPS: &discovery.EndpointSlice{
				Endpoints: []discovery.Endpoint{
					{
						Hints: &discovery.EndpointHints{
							ForZones: []discovery.ForZone{{Name: "zone-a"}},
						},
					},

import org.gradle.model.internal.type.ModelType;

import java.util.Collections;
import java.util.List;
import java.util.Map;

import static org.gradle.model.internal.core.NodeInitializerContext.forType;

public class ManagedModelCreationRuleExtractor extends AbstractModelCreationRuleExtractor {
    private static final ModelType<NodeInitializerRegistry> NODE_INITIALIZER_REGISTRY = ModelType.of(NodeInitializerRegistry.class);

import org.gradle.model.internal.manage.binding.InvalidManagedTypeException

import static org.gradle.model.ModelTypeTesting.fullyQualifiedNameOf
import static org.gradle.model.internal.core.NodeInitializerContext.forType

class ManagedNodeBackedModelMapTest extends NodeBackedModelMapSpec<NamedThingInterface, SpecialNamedThingInterface> {

    Class<NamedThingInterface> itemClass = NamedThingInterface

        when:
        def instanceFactory = scheme.forType(UsesAnnotation1ForInjection)
        then:
        instanceFactory.serviceInjectionTriggeredByAnnotation(Annotation1)
        !instanceFactory.serviceInjectionTriggeredByAnnotation(Annotation2)

        when:
        instanceFactory = scheme.forType(UsesAnnotationsForInjection)
        then:

}

var xxx_messageInfo_EndpointSliceList proto.InternalMessageInfo

func (m *ForZone) Reset()      { *m = ForZone{} }
func (*ForZone) ProtoMessage() {}
func (*ForZone) Descriptor() ([]byte, []int) {
	return fileDescriptor_2237b452324cf77e, []int{6}
}
func (m *ForZone) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ForZone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]