type Manager interface {
	// Update is used when the object has already been merged (non-apply
	// use-case), and simply updates the managed fields in the output
	// object.
	//  * `liveObj` is not mutated by this function
	//  * `newObj` may be mutated by this function
	// Returns the new object with managedFields removed, and the object's new
	// proposed managedFields separately.

  @Model void person(Person p) {}
// end::create-rule[]

// tag::plugin-mutate-rule[]
  //Create a rule that modifies a Person and takes no other inputs
  @Mutate void setFirstName(Person p) {
    p.firstName = "John"
  }
// end::plugin-mutate-rule[]

// tag::task-create-rule[]
  //Create a rule that modifies a ModelMap<Task> and takes as input a Person
  @Mutate void createHelloTask(ModelMap<Task> tasks, Person p) {

    @Override
    public void upToDateWhen(final Closure upToDateClosure) {
        taskMutator.mutate("TaskOutputs.upToDateWhen(Closure)", () -> {
            upToDateSpec = upToDateSpec.and(upToDateClosure);
        });
    }

    @Override
    public void upToDateWhen(final Spec<? super Task> spec) {
        taskMutator.mutate("TaskOutputs.upToDateWhen(Spec)", () -> {
            upToDateSpec = upToDateSpec.and(spec);
        });

    }

    static class ByPathBoundInputsChildRule extends RuleSource {
        @Mutate
        void mutateFirst(@Path("first") MutableValue first) {
            first.value = "first"
        }

        @Mutate
        void mutateSecond(@Path("second") MutableValue second, @Path("first") MutableValue first) {
            second.value = "from first: $first.value"

                @Mutate
                void setOs(Platform platform) {
                    platform.operatingSystem = new OperatingSystem()
                }

                @Mutate
                void setOsName(@Path("platform.operatingSystem") OperatingSystem os) {
                  os.name = "foo"
                }

                @Mutate

        expect:
        def reference = ModelReference.of("some.path", String).atState(ModelNode.State.Mutated)
        reference.scope == null
        reference.path == ModelPath.path("some.path")
        reference.type == ModelType.of(String)
        !reference.untyped
        reference.state == ModelNode.State.Mutated

        def original = ModelReference.of(String)
        original.atState(original.state).is(original)
    }

        taskMutator.mutate("Task.setDependsOn(Iterable)", new Runnable() {
            @Override
            public void run() {
                lifecycleDependencies.setValues(dependsOn);
            }
        });
    }

    @Override
    public void onlyIf(final Closure onlyIfClosure) {
        taskMutator.mutate("Task.onlyIf(Closure)", new Runnable() {
            @Override

    }

    public static ModelRegistry mutate(ModelRegistry modelRegistry, Transformer<? extends ModelAction, ? super ModelActionBuilder<Object>> definition) {
        return configure(modelRegistry, Mutate, definition);
    }

    public static <T> ModelRegistry mutate(ModelRegistry modelRegistry, Class<T> type, Action<? super T> action) {
        return applyInternal(modelRegistry, Mutate, type, action);
    }

                    platform.operatingSystem.name = "windows"
                }

                @Mutate
                void configurePlatform(Platform platform) {
                    platform.operatingSystem.name = "${platform.operatingSystem.name} 10"
                }

                @Mutate
                void addTask(ModelMap<Task> tasks, @Path("platform.operatingSystem") OperatingSystem os) {

     *
     * @param path the project path
     *
     * @return a mutable dependency, added to this container
     */
    ProjectDependencySpecBuilder project(String path);

    /**
     * Defines a new dependency, based on a library name. The returned dependency can be mutated.
     *
     * @param name of the library
     *