private final Iterable<? extends RuleBinder> binders;
    private final Transformer<? extends Collection<? extends ModelPath>, ? super ModelPath> suggestionsProvider;

    public UnboundRulesProcessor(Iterable<? extends RuleBinder> binders, Transformer<? extends Collection<? extends ModelPath>, ? super ModelPath> suggestionsProvider) {
        this.binders = binders;
        this.suggestionsProvider = suggestionsProvider;
    }

        return action(modelPath, inputType, inputType.toString(), action);
    }

    public <I> ModelAction action(String modelPath, ModelType<I> inputType, BiAction<? super T, ? super I> action) {
        return action(modelPath, inputType, modelPath, action);
    }

        return super.isSatisfiedBy(element) && !isVoidMethod(element);
    }

    @Override
    protected <R, S> ExtractedModelRule buildRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition) {
        return new ExtractedUnmanagedCreationRule<R, S>(modelPath, ruleDefinition);
    }

    @Override
    public String getDescription() {

    }

    private final ModelNodeInternal root;
    private final Map<ModelPath, ModelNodeInternal> flattened = new TreeMap<>();
    private final SetMultimap<ModelPath, ModelListener> pathListeners = LinkedHashMultimap.create();
    private final SetMultimap<ModelPath, ModelListener> parentListeners = LinkedHashMultimap.create();
    private final SetMultimap<ModelPath, ModelListener> ancestorListeners = LinkedHashMultimap.create();

    }

    protected abstract <R, S> ExtractedModelRule buildRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition);

    protected static abstract class ExtractedCreationRule<R, S>  extends AbstractExtractedModelRule {
        protected final ModelPath modelPath;
        private final boolean hidden;

        public ExtractedCreationRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition) {

            @Override
            protected ModelSpec scope(ModelPath scope, Predicate<? super MutableModelNode> matcher) {
                return parent.scope(scope, matcher);
            }
        };
    }

    private static class BasicPredicate extends ModelSpec {
        private final ModelPath path;
        private final ModelPath parent;
        private final ModelPath ancestor;

    }

    def "can replace path"() {
        expect:
        def reference = ModelReference.of(ModelPath.path("some.path"), ModelType.of(String), ModelNode.State.Mutated).withPath(ModelPath.path("other.path"))
        reference.scope == null
        reference.path == ModelPath.path("other.path")
        reference.type == ModelType.of(String)
        !reference.untyped
        reference.state == ModelNode.State.Mutated
    }

            }
        }
    }

    private class TypePredicateIndex {
        final Map<ModelPath, ScopeIndex> scopes = new LinkedHashMap<>();

        public void addNodeToScope(ModelPath path, ModelNodeInternal node) {
            scopeForPath(path).addNode(node);
        }

        public void removeNodeFromScope(ModelPath path, ModelNodeInternal node) {
            scopeForPath(path).removeNode(node);
        }

        }
    }

    private static class NonReferenceDescendantsSpec extends ModelSpec {
        private final ModelPath scope;

        private NonReferenceDescendantsSpec(ModelPath scope) {
            this.scope = scope;
        }

        @Nullable
        @Override
        public ModelPath getAncestor() {
            return scope;
        }

        @Override

     * @param state the desired node state
     * @return the node at the desired state
     */
    ModelNode atStateOrLater(ModelPath path, ModelNode.State state);
    <T> T atStateOrLater(ModelPath path, ModelType<T> type, ModelNode.State state);

    ModelNode.State state(ModelPath path);

    void remove(ModelPath path);

    /**
     * Attempts to bind the references of all model rules known at this point in time.
     * <p>