diff --git a/buffet/commands/object_schema.cc b/buffet/commands/object_schema.cc
index 5b565ed..96fe952 100644
--- a/buffet/commands/object_schema.cc
+++ b/buffet/commands/object_schema.cc
@@ -23,10 +23,24 @@
 // Generates an error if the string identifies an unknown type.
 std::unique_ptr<PropType> CreatePropType(const std::string& type_name,
                                          chromeos::ErrorPtr* error) {
+  std::string primary_type;
+  std::string array_type;
+  chromeos::string_utils::SplitAtFirst(type_name, ".", &primary_type,
+                                       &array_type, false);
   std::unique_ptr<PropType> prop;
   ValueType type;
-  if (PropType::GetTypeFromTypeString(type_name, &type))
+  if (PropType::GetTypeFromTypeString(primary_type, &type)) {
     prop = PropType::Create(type);
+    if (prop && type == ValueType::Array && !array_type.empty()) {
+      auto items_type = CreatePropType(array_type, error);
+      if (items_type) {
+        prop->GetArray()->SetItemType(std::move(items_type));
+      } else {
+        prop.reset();
+        return prop;
+      }
+    }
+  }
   if (!prop) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
                                  errors::commands::kUnknownType,
@@ -63,7 +77,8 @@
 // to deduce the PropType from. Returns the string name of the type detected
 // or empty string is type detection failed.
 std::string DetectArrayType(const base::ListValue* list,
-                            const PropType* base_schema) {
+                            const PropType* base_schema,
+                            bool allow_arrays) {
   std::string type_name;
   if (base_schema) {
     type_name = base_schema->GetTypeAsString();
@@ -86,6 +101,23 @@
       case base::Value::TYPE_DICTIONARY:
         type_name = PropType::GetTypeStringFromType(ValueType::Object);
         break;
+      case base::Value::TYPE_LIST: {
+        if (allow_arrays) {
+          type_name = PropType::GetTypeStringFromType(ValueType::Array);
+          const base::ListValue* first_element_list = nullptr;
+          if (first_element->GetAsList(&first_element_list)) {
+            // We do not allow arrays of arrays.
+            auto child_type = DetectArrayType(first_element_list, nullptr,
+                                              false);
+            if (child_type.empty()) {
+              type_name.clear();
+            } else {
+              type_name += '.' + child_type;
+            }
+          }
+        }
+        break;
+      }
       default:
         // The rest are unsupported.
         break;
@@ -105,7 +137,7 @@
   std::unique_ptr<PropType> prop;
   const base::ListValue* list = nullptr;
   CHECK(value.GetAsList(&list)) << "Unable to get array value";
-  std::string type_name = DetectArrayType(list, base_schema);
+  std::string type_name = DetectArrayType(list, base_schema, true);
   if (type_name.empty()) {
     ErrorInvalidTypeInfo(error);
     return prop;
@@ -165,11 +197,15 @@
   if (dict->HasKey(commands::attributes::kObject_Properties))
     return PropType::GetTypeStringFromType(ValueType::Object);
 
+  // If we have "items", it's an array.
+  if (dict->HasKey(commands::attributes::kItems))
+    return PropType::GetTypeStringFromType(ValueType::Array);
+
   // If we have "enum", it's an array. Detect type from array elements.
   const base::ListValue* list = nullptr;
   if (dict->GetListWithoutPathExpansion(
       commands::attributes::kOneOf_Enum, &list))
-    return DetectArrayType(list, base_schema);
+    return DetectArrayType(list, base_schema, true);
 
   // If we have "default", try to use it for type detection.
   if (dict->Get(commands::attributes::kDefault, &value)) {
@@ -181,9 +217,17 @@
       return PropType::GetTypeStringFromType(ValueType::Boolean);
     if (value->IsType(base::Value::TYPE_STRING))
       return PropType::GetTypeStringFromType(ValueType::String);
+    if (value->IsType(base::Value::TYPE_LIST)) {
+      CHECK(value->GetAsList(&list)) << "List value expected";
+      std::string child_type = DetectArrayType(list, base_schema, false);
+      if (!child_type.empty()) {
+        return PropType::GetTypeStringFromType(ValueType::Array) + '.' +
+               child_type;
+      }
+    }
   }
 
-  return std::string();
+  return std::string{};
 }
 
 // Helper function for PropFromJson to handle the case of parameter being
diff --git a/buffet/commands/object_schema_unittest.cc b/buffet/commands/object_schema_unittest.cc
index f257a67..b0332d2 100644
--- a/buffet/commands/object_schema_unittest.cc
+++ b/buffet/commands/object_schema_unittest.cc
@@ -26,20 +26,25 @@
 namespace {
 
 template<typename T>
-std::vector<T> GetOneOfValues(const buffet::PropType* prop_type) {
+std::vector<T> GetArrayValues(const buffet::native_types::Array& arr) {
   std::vector<T> values;
-  auto one_of = static_cast<const buffet::ConstraintOneOf*>(
-      prop_type->GetConstraint(buffet::ConstraintType::OneOf));
-  if (!one_of)
-    return values;
-
-  values.reserve(one_of->set_.value.size());
-  for (const auto& prop_value : one_of->set_.value) {
+  values.reserve(arr.size());
+  for (const auto& prop_value : arr) {
     values.push_back(prop_value->GetValueAsAny().Get<T>());
   }
   return values;
 }
 
+template<typename T>
+std::vector<T> GetOneOfValues(const buffet::PropType* prop_type) {
+  auto one_of = static_cast<const buffet::ConstraintOneOf*>(
+      prop_type->GetConstraint(buffet::ConstraintType::OneOf));
+  if (!one_of)
+    return {};
+
+  return GetArrayValues<T>(one_of->set_.value);
+}
+
 }  // anonymous namespace
 
 TEST(CommandSchema, IntPropType_Empty) {
@@ -57,6 +62,7 @@
   EXPECT_EQ(nullptr, prop.GetDouble());
   EXPECT_EQ(nullptr, prop.GetString());
   EXPECT_EQ(nullptr, prop.GetObject());
+  EXPECT_EQ(nullptr, prop.GetArray());
 }
 
 TEST(CommandSchema, IntPropType_ToJson) {
@@ -182,6 +188,7 @@
   EXPECT_EQ(nullptr, prop.GetDouble());
   EXPECT_EQ(nullptr, prop.GetString());
   EXPECT_EQ(nullptr, prop.GetObject());
+  EXPECT_EQ(nullptr, prop.GetArray());
 }
 
 TEST(CommandSchema, BoolPropType_ToJson) {
@@ -274,6 +281,7 @@
   EXPECT_EQ(&prop, prop.GetDouble());
   EXPECT_EQ(nullptr, prop.GetString());
   EXPECT_EQ(nullptr, prop.GetObject());
+  EXPECT_EQ(nullptr, prop.GetArray());
 }
 
 TEST(CommandSchema, DoublePropType_ToJson) {
@@ -396,6 +404,7 @@
   EXPECT_EQ(nullptr, prop.GetDouble());
   EXPECT_EQ(&prop, prop.GetString());
   EXPECT_EQ(nullptr, prop.GetObject());
+  EXPECT_EQ(nullptr, prop.GetArray());
 }
 
 TEST(CommandSchema, StringPropType_ToJson) {
@@ -522,6 +531,7 @@
   EXPECT_EQ(nullptr, prop.GetDouble());
   EXPECT_EQ(nullptr, prop.GetString());
   EXPECT_EQ(&prop, prop.GetObject());
+  EXPECT_EQ(nullptr, prop.GetArray());
 }
 
 TEST(CommandSchema, ObjectPropType_ToJson) {
@@ -669,6 +679,162 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
+TEST(CommandSchema, ArrayPropType_Empty) {
+  buffet::ArrayPropType prop;
+  EXPECT_FALSE(prop.HasOverriddenAttributes());
+  EXPECT_FALSE(prop.IsBasedOnSchema());
+  EXPECT_EQ(nullptr, prop.GetDefaultValue());
+  EXPECT_EQ(nullptr, prop.GetItemTypePtr());
+  prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+  EXPECT_TRUE(prop.HasOverriddenAttributes());
+  EXPECT_FALSE(prop.IsBasedOnSchema());
+  EXPECT_NE(nullptr, prop.GetItemTypePtr());
+}
+
+TEST(CommandSchema, ArrayPropType_Types) {
+  buffet::ArrayPropType prop;
+  EXPECT_EQ(nullptr, prop.GetInt());
+  EXPECT_EQ(nullptr, prop.GetBoolean());
+  EXPECT_EQ(nullptr, prop.GetDouble());
+  EXPECT_EQ(nullptr, prop.GetString());
+  EXPECT_EQ(nullptr, prop.GetObject());
+  EXPECT_EQ(&prop, prop.GetArray());
+}
+
+TEST(CommandSchema, ArrayPropType_ToJson) {
+  buffet::ArrayPropType prop;
+  prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+  EXPECT_EQ("{'items':'integer'}",
+            ValueToString(prop.ToJson(false, nullptr).get()));
+  EXPECT_EQ("{'items':{'type':'integer'},'type':'array'}",
+            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_FALSE(prop.IsBasedOnSchema());
+  buffet::ArrayPropType prop2;
+  prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
+  EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
+  EXPECT_TRUE(prop2.IsBasedOnSchema());
+  prop2.FromJson(CreateDictionaryValue("{'default':[1,2,3]}").get(),
+                 &prop, nullptr);
+  EXPECT_EQ("{'default':[1,2,3]}",
+            ValueToString(prop2.ToJson(false, nullptr).get()));
+  EXPECT_EQ("{'default':[1,2,3],'items':{'type':'integer'},'type':'array'}",
+            ValueToString(prop2.ToJson(true, nullptr).get()));
+}
+
+TEST(CommandSchema, ArrayPropType_FromJson) {
+  buffet::ArrayPropType prop;
+  EXPECT_TRUE(prop.FromJson(
+      CreateDictionaryValue("{'items':'integer'}").get(), nullptr, nullptr));
+  EXPECT_EQ(buffet::ValueType::Int, prop.GetItemTypePtr()->GetType());
+
+  buffet::ArrayPropType prop2;
+  ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
+    "{'items':'string','default':['foo', 'bar', 'baz']}").get(), nullptr,
+      nullptr));
+  ASSERT_NE(nullptr, prop2.GetDefaultValue());
+  const buffet::ArrayValue* defval = prop2.GetDefaultValue()->GetArray();
+  ASSERT_NE(nullptr, defval);
+  EXPECT_EQ((std::vector<std::string>{"foo", "bar", "baz"}),
+            GetArrayValues<std::string>(defval->GetValue()));
+}
+
+TEST(CommandSchema, ArrayPropType_Validate) {
+  buffet::ArrayPropType prop;
+  prop.FromJson(CreateDictionaryValue(
+      "{'items':{'minimum':2.3, 'maximum':10.5}}").get(), nullptr,
+      nullptr);
+
+  chromeos::ErrorPtr error;
+  EXPECT_TRUE(prop.ValidateValue(CreateValue("[3,4,10.5]").get(), &error));
+  error.reset();
+
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("[2]").get(), &error));
+  EXPECT_EQ("out_of_range", error->GetCode());
+  EXPECT_EQ("Value 2 is out of range. It must not be less than 2.3",
+            error->GetMessage());
+  error.reset();
+
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("[4, 5, 20]").get(), &error));
+  EXPECT_EQ("out_of_range", error->GetCode());
+  EXPECT_EQ("Value 20 is out of range. It must not be greater than 10.5",
+            error->GetMessage());
+  error.reset();
+}
+
+TEST(CommandSchema, ArrayPropType_Validate_Enum) {
+  buffet::ArrayPropType prop;
+  prop.FromJson(CreateDictionaryValue(
+      "{'items':'integer', 'enum':[[1], [2,3], [4,5,6]]}").get(), nullptr,
+      nullptr);
+
+  chromeos::ErrorPtr error;
+  EXPECT_TRUE(prop.ValidateValue(CreateValue("[2,3]").get(), &error));
+  error.reset();
+
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("[2]").get(), &error));
+  EXPECT_EQ("out_of_range", error->GetCode());
+  EXPECT_EQ("Value [2] is invalid. Expected one of [[1],[2,3],[4,5,6]]",
+            error->GetMessage());
+  error.reset();
+
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("[2,3,4]").get(), &error));
+  EXPECT_EQ("out_of_range", error->GetCode());
+  error.reset();
+}
+
+TEST(CommandSchema, ArrayPropType_CreateValue) {
+  buffet::ArrayPropType prop;
+  ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
+      "{'items':{'properties':{'width':'integer','height':'integer'}}}").get(),
+      nullptr, nullptr));
+
+  chromeos::ErrorPtr error;
+  buffet::native_types::Array arr;
+
+  auto val = prop.CreateValue(arr, &error);
+  ASSERT_NE(nullptr, val.get());
+  EXPECT_EQ(nullptr, error.get());
+  EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+  EXPECT_EQ("[]", ValueToString(val->ToJson(nullptr).get()));
+
+  buffet::IntPropType int_type;
+  buffet::ObjectPropType obj_type;
+  ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
+      "{'properties':{'width':'integer','height':'integer'}}").get(),
+      nullptr, nullptr));
+  arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
+    {"width", int_type.CreateValue(10, nullptr)},
+    {"height", int_type.CreateValue(20, nullptr)},
+  }, nullptr));
+  arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
+    {"width", int_type.CreateValue(17, nullptr)},
+    {"height", int_type.CreateValue(18, nullptr)},
+  }, nullptr));
+
+  val = prop.CreateValue(arr, &error);
+  ASSERT_NE(nullptr, val.get());
+  EXPECT_EQ(nullptr, error.get());
+  EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+  EXPECT_EQ("[{'height':20,'width':10},{'height':18,'width':17}]",
+            ValueToString(val->ToJson(nullptr).get()));
+
+  val = prop.CreateValue("blah", &error);
+  EXPECT_EQ(nullptr, val.get());
+  ASSERT_NE(nullptr, error.get());
+  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+}
+
+TEST(CommandSchema, ArrayPropType_NestedArrays_NotSupported) {
+  buffet::ArrayPropType prop;
+  chromeos::ErrorPtr error;
+  EXPECT_FALSE(prop.FromJson(CreateDictionaryValue(
+      "{'items':{'items':'integer'}}").get(), nullptr, &error));
+  EXPECT_EQ(buffet::errors::commands::kInvalidObjectSchema, error->GetCode());
+  error.reset();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeName) {
   buffet::ObjectSchema schema;
   const char* schema_str = "{"
@@ -703,17 +869,23 @@
   const char* schema_str = "{"
       "'param1':{'type':'integer'},"
       "'param2':{'type':'number'},"
-      "'param3':{'type':'string'}"
+      "'param3':{'type':'string'},"
+      "'param4':{'type':'array', 'items':'integer'},"
+      "'param5':{'type':'object', 'properties':{'p1':'integer'}}"
       "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
   EXPECT_EQ(buffet::ValueType::Int, schema.GetProp("param1")->GetType());
   EXPECT_EQ(buffet::ValueType::Double, schema.GetProp("param2")->GetType());
   EXPECT_EQ(buffet::ValueType::String, schema.GetProp("param3")->GetType());
+  EXPECT_EQ(buffet::ValueType::Array, schema.GetProp("param4")->GetType());
+  EXPECT_EQ(buffet::ValueType::Object, schema.GetProp("param5")->GetType());
   EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
   EXPECT_EQ("number", schema.GetProp("param2")->GetTypeAsString());
   EXPECT_EQ("string", schema.GetProp("param3")->GetTypeAsString());
-  EXPECT_EQ(nullptr, schema.GetProp("param4"));
+  EXPECT_EQ("array", schema.GetProp("param4")->GetTypeAsString());
+  EXPECT_EQ("object", schema.GetProp("param5")->GetTypeAsString());
+  EXPECT_EQ(nullptr, schema.GetProp("param77"));
 
   int min_int = (std::numeric_limits<int>::min)();
   int max_int = (std::numeric_limits<int>::max)();
@@ -745,7 +917,9 @@
       "'param13':{'default':13.5},"
       "'param14':{'default':true},"
       "'param15':{'default':false},"
-      "'param16':{'default':'foobar'}"
+      "'param16':{'default':'foobar'},"
+      "'param17':{'default':[1,2,3]},"
+      "'param18':{'items':'number', 'default':[]}"
       "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
@@ -765,6 +939,14 @@
   EXPECT_EQ("boolean", schema.GetProp("param14")->GetTypeAsString());
   EXPECT_EQ("boolean", schema.GetProp("param15")->GetTypeAsString());
   EXPECT_EQ("string", schema.GetProp("param16")->GetTypeAsString());
+  EXPECT_EQ("array", schema.GetProp("param17")->GetTypeAsString());
+  auto prop17 = schema.GetProp("param17");
+  EXPECT_EQ("integer",
+            prop17->GetArray()->GetItemTypePtr()->GetTypeAsString());
+  EXPECT_EQ("array", schema.GetProp("param18")->GetTypeAsString());
+  auto prop18 = schema.GetProp("param18");
+  EXPECT_EQ("number",
+            prop18->GetArray()->GetItemTypePtr()->GetTypeAsString());
 
   int min_int = (std::numeric_limits<int>::min)();
   int max_int = (std::numeric_limits<int>::max)();
@@ -804,6 +986,11 @@
   EXPECT_FALSE(val->GetBoolean()->GetValue());
   val = schema.GetProp("param16")->GetDefaultValue();
   EXPECT_EQ("foobar", val->GetString()->GetValue());
+  val = schema.GetProp("param17")->GetDefaultValue();
+  EXPECT_EQ((std::vector<int>{1, 2, 3}),
+            GetArrayValues<int>(val->GetArray()->GetValue()));
+  val = schema.GetProp("param18")->GetDefaultValue();
+  EXPECT_TRUE(val->GetArray()->GetValue().empty());
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Array) {
@@ -818,8 +1005,11 @@
       "'param7' :{'type':'integer', 'enum':[1,2,3]},"
       "'param8' :{'type':'number',  'enum':[1,2,3]},"
       "'param9' :{'type':'number',  'enum':[]},"
-      "'param10':{'type':'integer', 'enum':[]}"
-      "}";
+      "'param10':{'type':'integer', 'enum':[]},"
+      "'param11':[[0,1],[2,3]],"
+      "'param12':[['foo','bar']],"
+      "'param13':{'enum':[['id0', 'id1']]}"
+     "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
   EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
@@ -833,6 +1023,21 @@
   EXPECT_EQ("number", schema.GetProp("param9")->GetTypeAsString());
   EXPECT_EQ("integer", schema.GetProp("param10")->GetTypeAsString());
 
+  auto prop_type11 = schema.GetProp("param11");
+  EXPECT_EQ("array", prop_type11->GetTypeAsString());
+  EXPECT_EQ("integer",
+            prop_type11->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
+  auto prop_type12 = schema.GetProp("param12");
+  EXPECT_EQ("array", prop_type12->GetTypeAsString());
+  EXPECT_EQ("string",
+            prop_type12->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
+  auto prop_type13 = schema.GetProp("param13");
+  EXPECT_EQ("array", prop_type12->GetTypeAsString());
+  EXPECT_EQ("string",
+            prop_type13->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
   EXPECT_EQ((std::vector<int>{0, 1, 2, 3}),
             GetOneOfValues<int>(schema.GetProp("param1")));
   EXPECT_EQ((std::vector<double>{0.0, 1.1, 2.2}),
@@ -985,7 +1190,8 @@
       "'param3':{'default':3.3},"
       "'param4':{'default':'four'},"
       "'param5':{'default':{'x':5,'y':6},"
-                "'properties':{'x':'integer','y':'integer'}}"
+                "'properties':{'x':'integer','y':'integer'}},"
+      "'param6':{'default':[1,2,3]}"
       "}}";
   ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                             nullptr));
@@ -1001,6 +1207,8 @@
   buffet::native_types::Object param5 = obj["param5"]->GetObject()->GetValue();
   EXPECT_EQ(5, param5["x"]->GetInt()->GetValue());
   EXPECT_EQ(6, param5["y"]->GetInt()->GetValue());
+  buffet::native_types::Array param6 = obj["param6"]->GetArray()->GetValue();
+  EXPECT_EQ((std::vector<int>{1, 2, 3}), GetArrayValues<int>(param6));
 
   // Specify some.
   value = prop.CreateValue();
@@ -1018,6 +1226,8 @@
   param5 = obj["param5"]->GetObject()->GetValue();
   EXPECT_EQ(-5, param5["x"]->GetInt()->GetValue());
   EXPECT_EQ(-6, param5["y"]->GetInt()->GetValue());
+  param6 = obj["param6"]->GetArray()->GetValue();
+  EXPECT_EQ((std::vector<int>{1, 2, 3}), GetArrayValues<int>(param6));
 
   // Specify all.
   value = prop.CreateValue();
@@ -1026,7 +1236,8 @@
       "'param2':22,"
       "'param3':333.3,"
       "'param4':'FOUR',"
-      "'param5':{'x':-55,'y':66}"
+      "'param5':{'x':-55,'y':66},"
+      "'param6':[-1, 0]"
       "}";
   ASSERT_TRUE(value->FromJson(CreateDictionaryValue(val_json).get(), nullptr));
   obj = value->GetObject()->GetValue();
@@ -1037,6 +1248,8 @@
   param5 = obj["param5"]->GetObject()->GetValue();
   EXPECT_EQ(-55, param5["x"]->GetInt()->GetValue());
   EXPECT_EQ(66, param5["y"]->GetInt()->GetValue());
+  param6 = obj["param6"]->GetArray()->GetValue();
+  EXPECT_EQ((std::vector<int>{-1, 0}), GetArrayValues<int>(param6));
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_BaseSchema_Failures) {
@@ -1105,4 +1318,52 @@
                                &error));
   EXPECT_EQ("out_of_range", error->GetFirstError()->GetCode());
   error.reset();
+
+  schema_str = "{"
+      "'param1':[[1,2.3]]"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+      "'param1':[[1,2],[3,4],['blah']]"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+      "'param1':{'default':[]}"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+      "'param1':[[[1]],[[2]]]"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+      "'param1':{'enum':[[['foo']]]}"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+      "'param1':{'default':[[1],[2]]}"
+      "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+  error.reset();
 }
diff --git a/buffet/commands/prop_constraints.cc b/buffet/commands/prop_constraints.cc
index 085fe26..f773290 100644
--- a/buffet/commands/prop_constraints.cc
+++ b/buffet/commands/prop_constraints.cc
@@ -160,9 +160,9 @@
 }
 
 // ConstraintOneOf --------------------------------------------------
-ConstraintOneOf::ConstraintOneOf(InheritableAttribute<ChoiceList> set)
+ConstraintOneOf::ConstraintOneOf(InheritableAttribute<native_types::Array> set)
     : set_(std::move(set)) {}
-ConstraintOneOf::ConstraintOneOf(ChoiceList set)
+ConstraintOneOf::ConstraintOneOf(native_types::Array set)
     : set_(std::move(set)) {}
 
 bool ConstraintOneOf::Validate(const PropValue& value,
@@ -180,7 +180,7 @@
 }
 
 std::unique_ptr<Constraint> ConstraintOneOf::Clone() const {
-  InheritableAttribute<ChoiceList> attr;
+  InheritableAttribute<native_types::Array> attr;
   attr.is_inherited = set_.is_inherited;
   attr.value.reserve(set_.value.size());
   for (const auto& prop_value : set_.value) {
@@ -190,7 +190,7 @@
 }
 
 std::unique_ptr<Constraint> ConstraintOneOf::CloneAsInherited() const {
-  ChoiceList cloned;
+  native_types::Array cloned;
   cloned.reserve(set_.value.size());
   for (const auto& prop_value : set_.value) {
     cloned.push_back(prop_value->Clone());
@@ -200,14 +200,7 @@
 
 std::unique_ptr<base::Value> ConstraintOneOf::ToJson(
     chromeos::ErrorPtr* error) const {
-  std::unique_ptr<base::ListValue> list(new base::ListValue);
-  for (const auto& prop_value : set_.value) {
-    auto json = prop_value->ToJson(error);
-    if (!json)
-      return std::unique_ptr<base::Value>();
-    list->Append(json.release());
-  }
-  return std::move(list);
+  return TypedValueToJson(set_.value, error);
 }
 
 const char* ConstraintOneOf::GetDictKey() const {
diff --git a/buffet/commands/prop_constraints.h b/buffet/commands/prop_constraints.h
index e5efdd2..c6b7e9b 100644
--- a/buffet/commands/prop_constraints.h
+++ b/buffet/commands/prop_constraints.h
@@ -297,10 +297,8 @@
 // Implementation of OneOf constraint for different data types.
 class ConstraintOneOf : public Constraint {
  public:
-  using ChoiceList = std::vector<std::unique_ptr<const PropValue>>;
-
-  explicit ConstraintOneOf(InheritableAttribute<ChoiceList> set);
-  explicit ConstraintOneOf(ChoiceList set);
+  explicit ConstraintOneOf(InheritableAttribute<native_types::Array> set);
+  explicit ConstraintOneOf(native_types::Array set);
 
   // Implementation of Constraint::GetType().
   ConstraintType GetType() const override {
@@ -331,7 +329,7 @@
   // Stores the list of acceptable values for the parameter.
   // |set_.is_inherited| indicates whether the constraint is inherited
   // from base schema or overridden.
-  InheritableAttribute<ChoiceList> set_;
+  InheritableAttribute<native_types::Array> set_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConstraintOneOf);
diff --git a/buffet/commands/prop_types.cc b/buffet/commands/prop_types.cc
index 3bb0577..a31f135 100644
--- a/buffet/commands/prop_types.cc
+++ b/buffet/commands/prop_types.cc
@@ -231,6 +231,7 @@
     {ValueType::String,      "string"},
     {ValueType::Boolean,     "boolean"},
     {ValueType::Object,      "object"},
+    {ValueType::Array,       "array"},
   };
   return map;
 }
@@ -272,6 +273,9 @@
   case buffet::ValueType::Object:
     prop = new ObjectPropType;
     break;
+  case buffet::ValueType::Array:
+    prop = new ArrayPropType;
+    break;
   }
   return std::unique_ptr<PropType>(prop);
 }
@@ -290,24 +294,15 @@
     const PropType* prop_type,
     chromeos::ErrorPtr* error) {
   std::unique_ptr<Constraint> constraint;
-  const base::ListValue* list = nullptr;
-  if (!value->GetListWithoutPathExpansion(commands::attributes::kOneOf_Enum,
-                                          &list)) {
-    chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
-                           errors::commands::kTypeMismatch,
-                           "Expecting an array");
+  const base::Value* list = nullptr;  // Owned by |value|
+  CHECK(value->Get(commands::attributes::kOneOf_Enum, &list))
+      << "'enum' property missing in JSON dictionary";
+  native_types::Array choice_list;
+  ArrayPropType array_type;
+  array_type.SetItemType(prop_type->Clone());
+  if (!TypedValueFromJson(list, &array_type, &choice_list, error))
     return constraint;
-  }
-  ConstraintOneOf::ChoiceList choice_list;
-  choice_list.reserve(list->GetSize());
-  for (const base::Value* item : *list) {
-    std::unique_ptr<PropValue> prop_value = prop_type->CreateValue();
-    if (!prop_value->FromJson(item, error))
-      return constraint;
-    choice_list.push_back(std::move(prop_value));
-  }
-  InheritableAttribute<ConstraintOneOf::ChoiceList> val(std::move(choice_list),
-                                                        false);
+  InheritableAttribute<native_types::Array> val(std::move(choice_list), false);
   constraint.reset(new ConstraintOneOf{std::move(val)});
   return constraint;
 }
@@ -362,7 +357,7 @@
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
     chromeos::ErrorPtr* error) {
-  if (!_Base::ConstraintsFromJson(value, processed_keys, error))
+  if (!Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
   if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
@@ -398,7 +393,7 @@
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
     chromeos::ErrorPtr* error) {
-  if (!_Base::ConstraintsFromJson(value, processed_keys, error))
+  if (!Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
   if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
@@ -459,7 +454,7 @@
 }
 
 std::unique_ptr<PropType> ObjectPropType::Clone() const {
-  auto cloned = _Base::Clone();
+  auto cloned = Base::Clone();
 
   cloned->GetObject()->object_schema_.is_inherited =
       object_schema_.is_inherited;
@@ -490,7 +485,7 @@
                                           const PropType* base_schema,
                                           std::set<std::string>* processed_keys,
                                           chromeos::ErrorPtr* error) {
-  if (!_Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
+  if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
     return false;
 
   using commands::attributes::kObject_Properties;
@@ -532,4 +527,87 @@
   object_schema_.is_inherited = false;
 }
 
+// ArrayPropType -------------------------------------------------------------
+
+ArrayPropType::ArrayPropType() {}
+
+bool ArrayPropType::HasOverriddenAttributes() const {
+  return PropType::HasOverriddenAttributes() ||
+         !item_type_.is_inherited;
+}
+
+std::unique_ptr<PropType> ArrayPropType::Clone() const {
+  auto cloned = Base::Clone();
+
+  cloned->GetArray()->item_type_.is_inherited = item_type_.is_inherited;
+  cloned->GetArray()->item_type_.value = item_type_.value->Clone();
+  return cloned;
+}
+
+std::unique_ptr<base::Value> ArrayPropType::ToJson(
+    bool full_schema, chromeos::ErrorPtr* error) const {
+  std::unique_ptr<base::Value> value = PropType::ToJson(full_schema, error);
+  if (value) {
+    base::DictionaryValue* dict = nullptr;
+    CHECK(value->GetAsDictionary(&dict)) << "Expecting a JSON object";
+    if (!item_type_.is_inherited || full_schema) {
+      auto type = item_type_.value->ToJson(full_schema, error);
+      if (!type) {
+        value.reset();
+        return value;
+      }
+      dict->SetWithoutPathExpansion(commands::attributes::kItems,
+                                    type.release());
+    }
+  }
+  return value;
+}
+
+bool ArrayPropType::ObjectSchemaFromJson(const base::DictionaryValue* value,
+                                         const PropType* base_schema,
+                                         std::set<std::string>* processed_keys,
+                                         chromeos::ErrorPtr* error) {
+  if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
+    return false;
+
+  using commands::attributes::kItems;
+
+  const PropType* base_type = nullptr;
+  if (base_schema)
+    base_type = base_schema->GetArray()->GetItemTypePtr();
+
+  const base::Value* type_value = nullptr;
+  if (value->GetWithoutPathExpansion(kItems, &type_value)) {
+    processed_keys->insert(kItems);
+    auto item_type = ObjectSchema::PropFromJson(*type_value, base_type, error);
+    if (!item_type)
+      return false;
+    if (item_type->GetType() == ValueType::Array) {
+      chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+                             errors::commands::kInvalidObjectSchema,
+                             "Arrays of arrays are not supported");
+      return false;
+    }
+    SetItemType(std::move(item_type));
+  } else if (!item_type_.value) {
+    if (base_type) {
+      item_type_.value = base_type->Clone();
+      item_type_.is_inherited = true;
+    } else {
+      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                                   errors::commands::kInvalidObjectSchema,
+                                   "Array type definition must include the "
+                                   "array item type ('%s' field not found)",
+                                   kItems);
+      return false;
+    }
+  }
+  return true;
+}
+
+void ArrayPropType::SetItemType(std::unique_ptr<const PropType> item_type) {
+  item_type_.value = std::move(item_type);
+  item_type_.is_inherited = false;
+}
+
 }  // namespace buffet
diff --git a/buffet/commands/prop_types.h b/buffet/commands/prop_types.h
index 1af057c..10ca853 100644
--- a/buffet/commands/prop_types.h
+++ b/buffet/commands/prop_types.h
@@ -26,6 +26,7 @@
 class StringPropType;
 class BooleanPropType;
 class ObjectPropType;
+class ArrayPropType;
 
 // PropType is a base class for all parameter type definition objects.
 // Property definitions of a particular type will derive from this class and
@@ -76,6 +77,8 @@
   virtual BooleanPropType const* GetBoolean() const { return nullptr; }
   virtual ObjectPropType* GetObject() { return nullptr; }
   virtual ObjectPropType const* GetObject() const { return nullptr; }
+  virtual ArrayPropType* GetArray() { return nullptr; }
+  virtual ArrayPropType const* GetArray() const { return nullptr; }
 
   // Makes a full copy of this type definition.
   virtual std::unique_ptr<PropType> Clone() const;
@@ -206,7 +209,7 @@
 template<class Derived, class Value, typename T>
 class NumericPropTypeBase : public PropTypeBase<Derived, Value, T> {
  public:
-  using _Base = PropTypeBase<Derived, Value, T>;
+  using Base = PropTypeBase<Derived, Value, T>;
   bool ConstraintsFromJson(const base::DictionaryValue* value,
                            std::set<std::string>* processed_keys,
                            chromeos::ErrorPtr* error) override;
@@ -254,7 +257,7 @@
 class StringPropType
     : public PropTypeBase<StringPropType, StringValue, std::string> {
  public:
-  using _Base = PropTypeBase<StringPropType, StringValue, std::string>;
+  using Base = PropTypeBase<StringPropType, StringValue, std::string>;
   // Overrides from the PropType base class.
   StringPropType* GetString() override { return this; }
   StringPropType const* GetString() const override { return this; }
@@ -283,7 +286,7 @@
 class ObjectPropType
     : public PropTypeBase<ObjectPropType, ObjectValue, native_types::Object> {
  public:
-  using _Base = PropTypeBase<ObjectPropType, ObjectValue, native_types::Object>;
+  using Base = PropTypeBase<ObjectPropType, ObjectValue, native_types::Object>;
   ObjectPropType();
 
   // Overrides from the ParamType base class.
@@ -310,6 +313,40 @@
  private:
   InheritableAttribute<std::unique_ptr<const ObjectSchema>> object_schema_;
 };
+
+// Parameter definition of Array type.
+class ArrayPropType
+    : public PropTypeBase<ArrayPropType, ArrayValue, native_types::Array> {
+ public:
+  using Base = PropTypeBase<ArrayPropType, ArrayValue, native_types::Array>;
+  ArrayPropType();
+
+  // Overrides from the ParamType base class.
+  bool HasOverriddenAttributes() const override;
+
+  ArrayPropType* GetArray() override { return this; }
+  ArrayPropType const* GetArray() const override { return this; }
+
+  std::unique_ptr<PropType> Clone() const override;
+
+  std::unique_ptr<base::Value> ToJson(bool full_schema,
+                                      chromeos::ErrorPtr* error) const override;
+
+  bool ObjectSchemaFromJson(const base::DictionaryValue* value,
+                            const PropType* base_schema,
+                            std::set<std::string>* processed_keys,
+                            chromeos::ErrorPtr* error) override;
+
+  // Returns a type for Array elements.
+  inline const PropType* GetItemTypePtr() const {
+    return item_type_.value.get();
+  }
+  void SetItemType(std::unique_ptr<const PropType> item_type);
+
+ private:
+  InheritableAttribute<std::unique_ptr<const PropType>> item_type_;
+};
+
 }  // namespace buffet
 
 #endif  // BUFFET_COMMANDS_PROP_TYPES_H_
diff --git a/buffet/commands/prop_values.h b/buffet/commands/prop_values.h
index 6f85a0c..228316f 100644
--- a/buffet/commands/prop_values.h
+++ b/buffet/commands/prop_values.h
@@ -27,7 +27,8 @@
   Double,
   String,
   Boolean,
-  Object
+  Object,
+  Array,
 };
 
 class PropValue;
@@ -36,6 +37,7 @@
 class StringValue;
 class BooleanValue;
 class ObjectValue;
+class ArrayValue;
 
 class PropType;
 
@@ -56,6 +58,10 @@
 inline ValueType GetValueType<native_types::Object>() {
   return ValueType::Object;
 }
+template<>
+inline ValueType GetValueType<native_types::Array>() {
+  return ValueType::Array;
+}
 
 // The base class for property values.
 // Concrete value classes of various types will be derived from this base.
@@ -91,6 +97,8 @@
   virtual BooleanValue const* GetBoolean() const { return nullptr; }
   virtual ObjectValue* GetObject() { return nullptr; }
   virtual ObjectValue const* GetObject() const { return nullptr; }
+  virtual ArrayValue* GetArray() { return nullptr; }
+  virtual ArrayValue const* GetArray() const { return nullptr; }
 
   // Makes a full copy of this value class.
   virtual std::unique_ptr<PropValue> Clone() const = 0;
@@ -118,14 +126,13 @@
   std::unique_ptr<const PropType> type_;
 };
 
-// A helper template base class for implementing simple (non-Object) value
-// classes.
+// A helper template base class for implementing value classes.
 template<typename Derived, typename T>
 class TypedValueBase : public PropValue {
  public:
-  // To help refer to this base class from derived classes, define _Base to
+  // To help refer to this base class from derived classes, define Base to
   // be this class.
-  using _Base = TypedValueBase<Derived, T>;
+  using Base = TypedValueBase<Derived, T>;
   // Expose the non-default constructor of the base class.
   using PropValue::PropValue;
 
@@ -150,7 +157,7 @@
   bool IsEqual(const PropValue* value) const override {
     if (GetType() != value->GetType())
       return false;
-    const _Base* value_base = static_cast<const _Base*>(value);
+    const Base* value_base = static_cast<const Base*>(value);
     return CompareValue(GetValue(), value_base->GetValue());
   }
 
@@ -166,7 +173,7 @@
 // Value of type Integer.
 class IntValue final : public TypedValueBase<IntValue, int> {
  public:
-  using _Base::_Base;  // Expose the custom constructor of the base class.
+  using Base::Base;  // Expose the custom constructor of the base class.
   IntValue* GetInt() override { return this; }
   IntValue const* GetInt() const override { return this; }
 };
@@ -174,7 +181,7 @@
 // Value of type Number.
 class DoubleValue final : public TypedValueBase<DoubleValue, double> {
  public:
-  using _Base::_Base;  // Expose the custom constructor of the base class.
+  using Base::Base;  // Expose the custom constructor of the base class.
   DoubleValue* GetDouble() override { return this; }
   DoubleValue const* GetDouble() const override { return this; }
 };
@@ -182,7 +189,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.
+  using Base::Base;  // Expose the custom constructor of the base class.
   StringValue* GetString() override { return this; }
   StringValue const* GetString() const override { return this; }
 };
@@ -190,7 +197,7 @@
 // Value of type Boolean.
 class BooleanValue final : public TypedValueBase<BooleanValue, bool> {
  public:
-  using _Base::_Base;  // Expose the custom constructor of the base class.
+  using Base::Base;  // Expose the custom constructor of the base class.
   BooleanValue* GetBoolean() override { return this; }
   BooleanValue const* GetBoolean() const override { return this; }
 };
@@ -199,10 +206,20 @@
 class ObjectValue final
     : public TypedValueBase<ObjectValue, native_types::Object> {
  public:
-  using _Base::_Base;  // Expose the custom constructor of the base class.
+  using Base::Base;  // Expose the custom constructor of the base class.
   ObjectValue* GetObject() override { return this; }
   ObjectValue const* GetObject() const override { return this; }
 };
+
+// Value of type Array.
+class ArrayValue final
+    : public TypedValueBase<ArrayValue, native_types::Array> {
+ public:
+  using Base::Base;  // Expose the custom constructor of the base class.
+  ArrayValue* GetArray() override { return this; }
+  ArrayValue const* GetArray() const override { return this; }
+};
+
 }  // namespace buffet
 
 #endif  // BUFFET_COMMANDS_PROP_VALUES_H_
diff --git a/buffet/commands/schema_constants.cc b/buffet/commands/schema_constants.cc
index 22a4766..12cc6b6 100644
--- a/buffet/commands/schema_constants.cc
+++ b/buffet/commands/schema_constants.cc
@@ -31,6 +31,7 @@
 const char kType[] = "type";
 const char kDisplayName[] = "displayName";
 const char kDefault[] = "default";
+const char kItems[] = "items";
 
 const char kNumeric_Min[] = "minimum";
 const char kNumeric_Max[] = "maximum";
@@ -40,7 +41,6 @@
 
 const char kOneOf_Enum[] = "enum";
 const char kOneOf_Metadata[] = "metadata";
-const char kOneOf_MetaSchema[] = "schema";
 
 const char kObject_Properties[] = "properties";
 
diff --git a/buffet/commands/schema_constants.h b/buffet/commands/schema_constants.h
index 1cfbc75..a686271 100644
--- a/buffet/commands/schema_constants.h
+++ b/buffet/commands/schema_constants.h
@@ -35,6 +35,7 @@
 extern const char kType[];
 extern const char kDisplayName[];
 extern const char kDefault[];
+extern const char kItems[];
 
 extern const char kNumeric_Min[];
 extern const char kNumeric_Max[];
@@ -44,7 +45,6 @@
 
 extern const char kOneOf_Enum[];
 extern const char kOneOf_Metadata[];
-extern const char kOneOf_MetaSchema[];
 
 extern const char kObject_Properties[];
 
diff --git a/buffet/commands/schema_utils.cc b/buffet/commands/schema_utils.cc
index 47516eb..10e9797 100644
--- a/buffet/commands/schema_utils.cc
+++ b/buffet/commands/schema_utils.cc
@@ -81,6 +81,18 @@
   return std::move(dict);
 }
 
+std::unique_ptr<base::Value> TypedValueToJson(const native_types::Array& value,
+                                              chromeos::ErrorPtr* error) {
+  std::unique_ptr<base::ListValue> list(new base::ListValue);
+  for (const auto& item : value) {
+    auto json = item->ToJson(error);
+    if (!json)
+      return std::unique_ptr<base::Value>();
+    list->Append(json.release());
+  }
+  return std::move(list);
+}
+
 bool TypedValueFromJson(const base::Value* value_in,
                         const PropType* type,
                         bool* value_out,
@@ -133,7 +145,8 @@
       const base::Value* param_value = nullptr;
       CHECK(dict->GetWithoutPathExpansion(pair.first, &param_value))
           << "Unable to get parameter";
-      if (!value->FromJson(param_value, error)) {
+      if (!value->FromJson(param_value, error) ||
+          !pair.second->ValidateValue(value->GetValueAsAny(), error)) {
         chromeos::Error::AddToPrintf(error, FROM_HERE,
                                      errors::commands::kDomain,
                                      errors::commands::kInvalidPropValue,
@@ -181,6 +194,31 @@
   return true;
 }
 
+bool TypedValueFromJson(const base::Value* value_in,
+                        const PropType* type,
+                        native_types::Array* value_out,
+                        chromeos::ErrorPtr* error) {
+  const base::ListValue* list = nullptr;
+  if (!value_in->GetAsList(&list))
+    return ReportUnexpectedJson(value_in, value_out, error);
+
+  CHECK(type) << "Array type definition must be provided";
+  CHECK(ValueType::Array == type->GetType()) << "Type must be Array";
+  const PropType* item_type = type->GetArray()->GetItemTypePtr();
+  CHECK(item_type) << "Incomplete array type definition";
+
+  value_out->reserve(list->GetSize());
+  for (const base::Value* item : *list) {
+    std::unique_ptr<PropValue> prop_value = item_type->CreateValue();
+    if (!prop_value->FromJson(item, error) ||
+        !item_type->ValidateValue(prop_value->GetValueAsAny(), error)) {
+      return false;
+    }
+    value_out->push_back(std::move(prop_value));
+  }
+  return true;
+}
+
 // Compares two sets of key-value pairs from two Objects.
 static bool obj_cmp(const native_types::Object::value_type& v1,
                     const native_types::Object::value_type& v2) {
@@ -196,6 +234,20 @@
   return pair == std::make_pair(obj1.end(), obj2.end());
 }
 
+bool operator==(const native_types::Array& arr1,
+                const native_types::Array& arr2) {
+  if (arr1.size() != arr2.size())
+    return false;
+
+  using Type = const native_types::Array::value_type;
+  // Compare two array items.
+  auto arr_cmp = [](const Type& v1, const Type& v2) {
+    return v1->IsEqual(v2.get());
+  };
+  auto pair = std::mismatch(arr1.begin(), arr1.end(), arr2.begin(), arr_cmp);
+  return pair == std::make_pair(arr1.end(), arr2.end());
+}
+
 std::string ToString(const native_types::Object& obj) {
   auto val = TypedValueToJson(obj, nullptr);
   std::string str;
@@ -203,6 +255,13 @@
   return str;
 }
 
+std::string ToString(const native_types::Array& arr) {
+  auto val = TypedValueToJson(arr, nullptr);
+  std::string str;
+  base::JSONWriter::Write(val.get(), &str);
+  return str;
+}
+
 chromeos::Any PropValueToDBusVariant(const PropValue* value) {
   if (value->GetType() != ValueType::Object)
     return value->GetValueAsAny();
diff --git a/buffet/commands/schema_utils.h b/buffet/commands/schema_utils.h
index 5709ebc..625b854 100644
--- a/buffet/commands/schema_utils.h
+++ b/buffet/commands/schema_utils.h
@@ -27,10 +27,16 @@
 namespace native_types {
 // C++ representation of object values.
 using Object = std::map<std::string, std::shared_ptr<const PropValue>>;
+// C++ representation of array of values.
+using Array = std::vector<std::shared_ptr<const PropValue>>;
 }  // namespace native_types
+
 // Converts an object to string.
 std::string ToString(const native_types::Object& obj);
 
+// Converts an array to string.
+std::string ToString(const native_types::Array& arr);
+
 // InheritableAttribute class is used for specifying various command parameter
 // attributes that can be inherited from a base (parent) schema.
 // The |value| still specifies the actual attribute values, whether it
@@ -61,6 +67,8 @@
                                               chromeos::ErrorPtr* error);
 std::unique_ptr<base::Value> TypedValueToJson(const native_types::Object& value,
                                               chromeos::ErrorPtr* error);
+std::unique_ptr<base::Value> TypedValueToJson(const native_types::Array& value,
+                                              chromeos::ErrorPtr* error);
 template<typename T>
 std::unique_ptr<base::Value> TypedValueToJson(const std::vector<T>& values,
                                               chromeos::ErrorPtr* error) {
@@ -97,9 +105,15 @@
                         const PropType* type,
                         native_types::Object* value_out,
                         chromeos::ErrorPtr* error);
+bool TypedValueFromJson(const base::Value* value_in,
+                        const PropType* type,
+                        native_types::Array* value_out,
+                        chromeos::ErrorPtr* error);
 
 bool operator==(const native_types::Object& obj1,
                 const native_types::Object& obj2);
+bool operator==(const native_types::Array& arr1,
+                const native_types::Array& arr2);
 
 // CompareValue is a helper function to help with implementing EqualsTo operator
 // for various data types. For most scalar types it is using operator==(),
diff --git a/buffet/commands/schema_utils_unittest.cc b/buffet/commands/schema_utils_unittest.cc
index 4f9eabe..25fa553 100644
--- a/buffet/commands/schema_utils_unittest.cc
+++ b/buffet/commands/schema_utils_unittest.cc
@@ -67,6 +67,16 @@
             ValueToString(buffet::TypedValueToJson(object, nullptr).get()));
 }
 
+TEST(CommandSchemaUtils, TypedValueToJson_Array) {
+  buffet::IntPropType int_type;
+  buffet::native_types::Array arr;
+
+  arr.push_back(int_type.CreateValue(640, nullptr));
+  arr.push_back(int_type.CreateValue(480, nullptr));
+  EXPECT_EQ("[640,480]",
+            ValueToString(buffet::TypedValueToJson(arr, nullptr).get()));
+}
+
 TEST(CommandSchemaUtils, TypedValueFromJson_Bool) {
   bool value;
 
@@ -187,6 +197,27 @@
   error.reset();
 }
 
+TEST(CommandSchemaUtils, TypedValueFromJson_Array) {
+  buffet::native_types::Array arr;
+  buffet::StringPropType str_type;
+  str_type.AddLengthConstraint(3, 100);
+  buffet::ArrayPropType type;
+  type.SetItemType(str_type.Clone());
+
+  EXPECT_TRUE(buffet::TypedValueFromJson(
+      CreateValue("['foo', 'bar']").get(), &type, &arr, nullptr));
+  buffet::native_types::Array arr2;
+  arr2.push_back(str_type.CreateValue(std::string{"foo"}, nullptr));
+  arr2.push_back(str_type.CreateValue(std::string{"bar"}, nullptr));
+  EXPECT_EQ(arr2, arr);
+
+  chromeos::ErrorPtr error;
+  EXPECT_FALSE(buffet::TypedValueFromJson(
+      CreateValue("['baz', 'ab']").get(), &type, &arr, &error));
+  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  error.reset();
+}
+
 TEST(CommandSchemaUtils, PropValueToDBusVariant) {
   buffet::IntPropType int_type;
   auto prop_value = int_type.CreateValue(5, nullptr);