private final ModelReference<?> subject;
        private final ModelType<T> type;
        private final List<ModelReference<?>> inputs;

        private UnmanagedElementCreationAction(ModelRuleDescriptor descriptor, ModelReference<?> subject, List<ModelReference<?>> inputs, ModelType<T> type) {
            this.subject = subject;
            this.inputs = inputs;
            this.descriptor = descriptor;

    }

    @Override
    public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
        return getActions(subject, descriptor, schema);
    }

    public static <T, E> Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor, final SpecializedMapSchema<T, E> schema) {

        }

        return foundTransforms.get(0);
    }

    /**
     * Returns grouped output for the given transformer type and transform subject.
     */
    public GroupedTransformOutputFixture transform(String transformer, String subject) {

        then:
        bindings.getRulesWithSubject(nodeAtState("a", ModelNode.State.Mutated)) as List == [rule]
        rule.subjectBinding.boundTo == node
    }

    def "locates the subject of a rule by-path when subject added after rule"() {
        when:
        def node = node("a")
        def rule = rule("a", ModelNode.State.Mutated)
        bindings.add(rule)

        then:
        !rule.subjectBinding.bound

      }

    fun build(): HeldCertificate {
      // Subject keys & identity.
      val subjectKeyPair = keyPair ?: generateKeyPair()
      val subjectPublicKeyInfo =
        CertificateAdapters.subjectPublicKeyInfo.fromDer(
          subjectKeyPair.public.encoded.toByteString(),
        )
      val subject: List<List<AttributeTypeAndValue>> = subject()

import org.gradle.internal.logging.text.TestStyledTextOutputFactory
import org.gradle.internal.time.Clock
import org.gradle.util.internal.TextUtil
import spock.lang.Specification
import spock.lang.Subject

@Subject(BuildResultLogger)
class BuildResultLoggerTest extends Specification {
    private StyledTextOutputFactory textOutputFactory = new TestStyledTextOutputFactory()

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

/**
 * Thrown when at attempt is made to mutate a subject of a rule after the rule has completed.
 * <p>
 * This can potentially happen when a reference to the subject is retained during a rule and then used afterwards,
 * Such as when an anonymous inner class or closure “closes over” the subject.
 */
@Incubating
public class ModelViewClosedException extends ReadOnlyModelViewException {

        with(transformOperation) {
            assertIsTransform()
            descriptor.transformer.displayName == "FileSizer"
            descriptor.subject.displayName == transformTarget()
            successful
        }
        with(events.operation("Task :app:resolve")) {
            assertIsTask()
            successful

        DeprecateAction(String subject) {
            super(subject);
        }

        @Override
        protected String createDefaultDeprecationIdDisplayName() {
            return subject;
        }

        @Override
        String formatSummary(String subject) {
            return String.format("%s has been deprecated.", subject);
        }

        @Override

// but we don't want an client library (which must include types), depending on a server library
const allAuthenticated = "system:authenticated"

func Convert_v1alpha1_Subject_To_rbac_Subject(in *rbacv1alpha1.Subject, out *api.Subject, s conversion.Scope) error {
	if err := autoConvert_v1alpha1_Subject_To_rbac_Subject(in, out, s); err != nil {
		return err
	}

	// specifically set the APIGroup for the three subjects recognized in v1alpha1