diff --git a/buffet/commands/prop_values.h b/buffet/commands/prop_values.h
index e03d39b..adaa91d 100644
--- a/buffet/commands/prop_values.h
+++ b/buffet/commands/prop_values.h
@@ -9,7 +9,8 @@
 #include <memory>
 #include <string>
 
-#include "buffet/commands/prop_constraints.h"
+#include "buffet/any.h"
+#include "buffet/commands/schema_utils.h"
 #include "buffet/error.h"
 
 namespace base {
@@ -24,38 +25,52 @@
   Int,
   Double,
   String,
-  Boolean
+  Boolean,
+  Object
 };
 
+class PropValue;
+class IntValue;
+class DoubleValue;
+class StringValue;
+class BooleanValue;
+class ObjectValue;
+
+class PropType;
+
 // Helper methods to get the parameter type enum value for the given
 // native C++ data representation.
 // The generic GetValueType<T>() is undefined, however particular
 // type specializations return the appropriate ValueType.
 template<typename T> ValueType GetValueType();  // Undefined.
-template<> ValueType GetValueType<int>();
-template<> ValueType GetValueType<double>();
-template<> ValueType GetValueType<std::string>();
-template<> ValueType GetValueType<bool>();
+template<>
+inline ValueType GetValueType<int>() { return ValueType::Int; }
+template<>
+inline ValueType GetValueType<double>() { return ValueType::Double; }
+template<>
+inline ValueType GetValueType<std::string>() { return ValueType::String; }
+template<>
+inline ValueType GetValueType<bool>() { return ValueType::Boolean; }
+template<>
+inline ValueType GetValueType<native_types::Object>() {
+  return ValueType::Object;
+}
 
-class ObjectSchema;
-
-class PropValue;
-class IntPropType;
-class DoublePropType;
-class StringPropType;
-class BooleanPropType;
-
-class IntValue;
-class DoubleValue;
-class StringValue;
-class BooleanValue;
-
-// The base class for parameter values.
+// The base class for property values.
 // Concrete value classes of various types will be derived from this base.
+// A property value is the actual command parameter value (or a concrete value
+// that can be used in constraints and presets). The PropValue is mostly
+// just parsed content of base::Value when a command is dispatched, however
+// it does have some additional functionality:
+//   - it has a reference to the type definition (PropType) which is used
+//     when validating the value, especially for "object" types.
+//   - it can be compared with another instances of values of the same type.
+//     This is used to validate the values against "enum"/"one of" constraints.
 class PropValue {
  public:
-  PropValue() = default;
-  virtual ~PropValue();
+  explicit PropValue(const PropType* type)
+      : type_(type) {}
+  virtual ~PropValue() = default;
 
   // Gets the type of the value.
   virtual ValueType GetType() const = 0;
@@ -69,6 +84,8 @@
   virtual StringValue const* GetString() const { return nullptr; }
   virtual BooleanValue* GetBoolean() { return nullptr; }
   virtual BooleanValue const* GetBoolean() const { return nullptr; }
+  virtual ObjectValue* GetObject() { return nullptr; }
+  virtual ObjectValue const* GetObject() const { return nullptr; }
 
   // Makes a full copy of this value class.
   virtual std::shared_ptr<PropValue> Clone() const = 0;
@@ -80,7 +97,19 @@
   // Parses a value from JSON.
   // If it fails, it returns false and provides additional information
   // via the |error| parameter.
-  virtual bool FromJson(const base::Value* value, ErrorPtr* error) = 0;
+  virtual bool FromJson(const base::Value* value,
+                        ErrorPtr* error) = 0;
+
+  // Returns the contained C++ value as Any.
+  virtual Any GetValueAsAny() const = 0;
+
+  // Return the type definition of this value.
+  const PropType* GetPropType() const { return type_; }
+  // Compares two values and returns true if they are equal.
+  virtual bool IsEqual(const PropValue* value) const = 0;
+
+ protected:
+  const PropType* type_;  // weak pointer
 };
 
 // A helper template base class for implementing simple (non-Object) value
@@ -88,6 +117,12 @@
 template<typename Derived, typename T>
 class TypedValueBase : public PropValue {
  public:
+  // To help refer to this base class from derived classes, define _Base to
+  // be this class.
+  using _Base = TypedValueBase<Derived, T>;
+  // Expose the non-default constructor of the base class.
+  using PropValue::PropValue;
+
   // Overrides from PropValue base class.
   virtual ValueType GetType() const override { return GetValueType<T>(); }
   virtual std::shared_ptr<PropValue> Clone() const override {
@@ -95,15 +130,24 @@
   }
 
   virtual std::unique_ptr<base::Value> ToJson(ErrorPtr* error) const override {
-    (void)error;  // unused.
-    return TypedValueToJson(value_);
+    return TypedValueToJson(value_, error);
   }
 
-  virtual bool FromJson(const base::Value* value, ErrorPtr* error) override {
-    return TypedValueFromJson(value, &value_, error);
+  virtual bool FromJson(const base::Value* value,
+                        ErrorPtr* error) override {
+    return TypedValueFromJson(value, GetPropType()->GetObjectSchemaPtr(),
+                              &value_, error);
   }
 
-  // Helper method to get and set the C++ representation of the value.
+  virtual bool IsEqual(const PropValue* value) const override {
+    if (GetType() != value->GetType())
+      return false;
+    const _Base* value_base = static_cast<const _Base*>(value);
+    return CompareValue(GetValue(), value_base->GetValue());
+  }
+
+  // Helper methods to get and set the C++ representation of the value.
+  virtual Any GetValueAsAny() const override { return value_; }
   const T& GetValue() const { return value_; }
   void SetValue(T value) { value_ = std::move(value); }
 
@@ -114,6 +158,7 @@
 // Value of type Integer.
 class IntValue final : public TypedValueBase<IntValue, int> {
  public:
+  using _Base::_Base;  // Expose the custom constructor of the base class.
   virtual IntValue* GetInt() override { return this; }
   virtual IntValue const* GetInt() const override { return this; }
 };
@@ -121,6 +166,7 @@
 // Value of type Number.
 class DoubleValue final : public TypedValueBase<DoubleValue, double> {
  public:
+  using _Base::_Base;  // Expose the custom constructor of the base class.
   virtual DoubleValue* GetDouble() override { return this; }
   virtual DoubleValue const* GetDouble() const override { return this; }
 };
@@ -128,6 +174,7 @@
 // Value of type String.
 class StringValue final : public TypedValueBase<StringValue, std::string> {
  public:
+  using _Base::_Base;  // Expose the custom constructor of the base class.
   virtual StringValue* GetString() override { return this; }
   virtual StringValue const* GetString() const override { return this; }
 };
@@ -135,10 +182,19 @@
 // Value of type Boolean.
 class BooleanValue final : public TypedValueBase<BooleanValue, bool> {
  public:
+  using _Base::_Base;  // Expose the custom constructor of the base class.
   virtual BooleanValue* GetBoolean() override { return this; }
   virtual BooleanValue const* GetBoolean() const override { return this; }
 };
 
+// Value of type Object.
+class ObjectValue final : public TypedValueBase<ObjectValue,
+                                                native_types::Object> {
+ public:
+  using _Base::_Base;  // Expose the custom constructor of the base class.
+  virtual ObjectValue* GetObject() override { return this; }
+  virtual ObjectValue const* GetObject() const override { return this; }
+};
 }  // namespace buffet
 
 #endif  // BUFFET_COMMANDS_PROP_VALUES_H_