diff --git a/include/mbgl/style/conversion.hpp b/include/mbgl/style/conversion.hpp
index d976e995db8..6f5bc5ed691 100644
--- a/include/mbgl/style/conversion.hpp
+++ b/include/mbgl/style/conversion.hpp
@@ -22,13 +22,13 @@ namespace conversion {
    A single template function serves as the public interface:
 
        template <class T>
-       optional<T> convert(const Value& value, Error& error);
+       optional<T> convert(const Convertible& input, Error& error);
 
    Where `T` is one of the above types. If the conversion fails, the result is empty, and the
    error parameter includes diagnostic text suitable for presentation to a library user. Otherwise,
    a filled optional is returned.
 
-   `Value` is a type that encapsulates a special form of polymorphism over various underlying types that
+   `Convertible` is a type that encapsulates a special form of polymorphism over various underlying types that
    can serve as input to the conversion algorithm. For instance, on macOS, we need to support
    conversion from both RapidJSON types, and a JSON structure represented with `NSArray`/`NSDictionary`/etc.
    On Qt, we need to support conversion from RapidJSON types and QVariant.
@@ -40,11 +40,11 @@ namespace conversion {
      * Runtime polymorphism using virtual methods requires extra heap allocation and ubiquitous
        use of std::unique_ptr, unsuitable for this performance-sensitive code.
 
-   Therefore, we're using a custom implementation where we manually create and dispatch through a table
-   of function pointers (vtable), while keeping the storage for any of the possible underlying types inline
-   on the stack.
+   Therefore, we're using a custom implementation of runtime polymorphism where we manually create and
+   dispatch through a table of function pointers (vtable), while keeping the storage for any of the possible
+   underlying types inline on the stack, using `std::aligned_storage`.
 
-   For a given underlying type T, an explicit specialization of ValueTraits<T> must be provided. This
+   For a given underlying type T, an explicit specialization of `ConversionTraits<T>` must be provided. This
    specialization must provide the following static methods:
 
       * `isUndefined(v)` -- returns a boolean indication whether `v` is undefined or a JSON null
@@ -65,32 +65,32 @@ namespace conversion {
       * `toNumber(v)` -- returns `optional<float>`, absence indicating `v` is not a JSON number
       * `toDouble(v)` -- returns `optional<double>`, absence indicating `v` is not a JSON number
       * `toString(v)` -- returns `optional<std::string>`, absence indicating `v` is not a JSON string
-      * `toValue(v)` -- returns `optional<mbgl::Value>`, a variant type, for generic conversion,
+      * `toValue(v)` -- returns `optional<Value>`, a variant type, for generic conversion,
         absence indicating `v` is not a boolean, number, or string. Numbers should be converted to
         unsigned integer, signed integer, or floating point, in descending preference.
 
-   In addition, the type T must be move-constructable. And finally, `Value::Storage`, a typedef for
+   In addition, the type T must be move-constructable. And finally, `Convertible::Storage`, a typedef for
    `std::aligned_storage_t`, must be large enough to satisfy the memory requirements for any of the
    possible underlying types. (A static assert will fail if this is not the case.)
 
-   `Value` itself is movable, but not copyable. A moved-from `Value` is in an invalid state; you must
-   not do anything with it except let it go out of scope.
+   `Convertible` itself is movable, but not copyable. A moved-from `Convertible` is in an invalid state;
+   you must not do anything with it except let it go out of scope.
 */
 
 struct Error { std::string message; };
 
 template <typename T>
-class ValueTraits;
+class ConversionTraits;
 
-class Value {
+class Convertible {
 public:
     template <typename T>
-    Value(const T value) : vtable(vtableForType<T>()) {
+    Convertible(const T value) : vtable(vtableForType<T>()) {
         static_assert(sizeof(Storage) >= sizeof(T), "Storage must be large enough to hold value type");
         new (static_cast<void*>(&storage)) T(value);
    }
 
-    Value(Value&& v)
+    Convertible(Convertible&& v)
         : vtable(v.vtable)
     {
         if (vtable) {
@@ -98,13 +98,13 @@ class Value {
         }
     }
 
-    ~Value() {
+    ~Convertible() {
         if (vtable) {
             vtable->destroy(storage);
         }
     }
 
-    Value& operator=(Value&& v) {
+    Convertible& operator=(Convertible&& v) {
         if (vtable) {
             vtable->destroy(storage);
         }
@@ -116,71 +116,71 @@ class Value {
         return *this;
     }
 
-    Value()                        = delete;
-    Value(const Value&)            = delete;
-    Value& operator=(const Value&) = delete;
+    Convertible()                              = delete;
+    Convertible(const Convertible&)            = delete;
+    Convertible& operator=(const Convertible&) = delete;
 
-    friend inline bool isUndefined(const Value& v) {
+    friend inline bool isUndefined(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isUndefined(v.storage);
     }
 
-    friend inline bool isArray(const Value& v) {
+    friend inline bool isArray(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isArray(v.storage);
     }
 
-    friend inline std::size_t arrayLength(const Value& v) {
+    friend inline std::size_t arrayLength(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->arrayLength(v.storage);
     }
 
-    friend inline Value arrayMember(const Value& v, std::size_t i) {
+    friend inline Convertible arrayMember(const Convertible& v, std::size_t i) {
         assert(v.vtable);
         return v.vtable->arrayMember(v.storage, i);
     }
 
-    friend inline bool isObject(const Value& v) {
+    friend inline bool isObject(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->isObject(v.storage);
     }
 
-    friend inline optional<Value> objectMember(const Value& v, const char * name) {
+    friend inline optional<Convertible> objectMember(const Convertible& v, const char * name) {
         assert(v.vtable);
         return v.vtable->objectMember(v.storage, name);
     }
 
-    friend inline optional<Error> eachMember(const Value& v, const std::function<optional<Error> (const std::string&, const Value&)>& fn) {
+    friend inline optional<Error> eachMember(const Convertible& v, const std::function<optional<Error> (const std::string&, const Convertible&)>& fn) {
         assert(v.vtable);
         return v.vtable->eachMember(v.storage, fn);
     }
 
-    friend inline optional<bool> toBool(const Value& v) {
+    friend inline optional<bool> toBool(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toBool(v.storage);
     }
 
-    friend inline optional<float> toNumber(const Value& v) {
+    friend inline optional<float> toNumber(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toNumber(v.storage);
     }
 
-    friend inline optional<double> toDouble(const Value& v) {
+    friend inline optional<double> toDouble(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toDouble(v.storage);
     }
 
-    friend inline optional<std::string> toString(const Value& v) {
+    friend inline optional<std::string> toString(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toString(v.storage);
     }
 
-    friend inline optional<mbgl::Value> toValue(const Value& v) {
+    friend inline optional<Value> toValue(const Convertible& v) {
         assert(v.vtable);
         return v.vtable->toValue(v.storage);
     }
 
-    friend inline optional<GeoJSON> toGeoJSON(const Value& v, Error& error) {
+    friend inline optional<GeoJSON> toGeoJSON(const Convertible& v, Error& error) {
         assert(v.vtable);
         return v.vtable->toGeoJSON(v.storage, error);
     }
@@ -202,17 +202,17 @@ class Value {
 
         bool        (*isArray)     (const Storage&);
         std::size_t (*arrayLength) (const Storage&);
-        Value       (*arrayMember) (const Storage&, std::size_t);
+        Convertible (*arrayMember) (const Storage&, std::size_t);
 
-        bool            (*isObject)     (const Storage&);
-        optional<Value> (*objectMember) (const Storage&, const char *);
-        optional<Error> (*eachMember)   (const Storage&, const std::function<optional<Error> (const std::string&, const Value&)>&);
+        bool                  (*isObject)     (const Storage&);
+        optional<Convertible> (*objectMember) (const Storage&, const char *);
+        optional<Error>       (*eachMember)   (const Storage&, const std::function<optional<Error> (const std::string&, const Convertible&)>&);
 
         optional<bool>        (*toBool)   (const Storage&);
         optional<float>       (*toNumber) (const Storage&);
         optional<double>      (*toDouble) (const Storage&);
         optional<std::string> (*toString) (const Storage&);
-        optional<mbgl::Value> (*toValue)  (const Storage&);
+        optional<Value>       (*toValue)  (const Storage&);
 
         // https://github.com/mapbox/mapbox-gl-native/issues/5623
         optional<GeoJSON> (*toGeoJSON) (const Storage&, Error&);
@@ -220,9 +220,8 @@ class Value {
 
     template <typename T>
     static VTable* vtableForType() {
-        using Traits = ValueTraits<T>;
-    
-        static Value::VTable vtable = {
+        using Traits = ConversionTraits<T>;
+        static VTable vtable = {
             [] (Storage&& src, Storage& dest) {
                 auto srcValue = reinterpret_cast<T&&>(src);
                 new (static_cast<void*>(&dest)) T(std::move(srcValue));
@@ -241,19 +240,19 @@ class Value {
                 return Traits::arrayLength(reinterpret_cast<const T&>(s));
             },
             [] (const Storage& s, std::size_t i) {
-                return Value(Traits::arrayMember(reinterpret_cast<const T&>(s), i));
+                return Convertible(Traits::arrayMember(reinterpret_cast<const T&>(s), i));
             },
             [] (const Storage& s) {
                 return Traits::isObject(reinterpret_cast<const T&>(s));
             },
             [] (const Storage& s, const char * key) {
                 optional<T> member = Traits::objectMember(reinterpret_cast<const T&>(s), key);
-                if (member) return optional<Value>(*member);
-                return optional<Value>();
+                if (member) return optional<Convertible>(*member);
+                return optional<Convertible>();
             },
-            [] (const Storage& s, const std::function<optional<Error> (const std::string&, const Value&)>& fn) {
+            [] (const Storage& s, const std::function<optional<Error> (const std::string&, const Convertible&)>& fn) {
                 return Traits::eachMember(reinterpret_cast<const T&>(s), [&](const std::string& k, const T& v) {
-                    return fn(k, Value(v));
+                    return fn(k, Convertible(v));
                 });
             },
             [] (const Storage& s) {
@@ -286,7 +285,7 @@ template <class T, class Enable = void>
 struct Converter;
 
 template <class T, class...Args>
-optional<T> convert(const Value& value, Error& error, Args&&...args) {
+optional<T> convert(const Convertible& value, Error& error, Args&&...args) {
     return Converter<T>()(value, error, std::forward<Args>(args)...);
 }
 
diff --git a/include/mbgl/style/conversion/constant.hpp b/include/mbgl/style/conversion/constant.hpp
index 50d31ab9a82..7b3249da52b 100644
--- a/include/mbgl/style/conversion/constant.hpp
+++ b/include/mbgl/style/conversion/constant.hpp
@@ -15,22 +15,22 @@ namespace conversion {
 
 template <>
 struct Converter<bool> {
-    optional<bool> operator()(const Value& value, Error& error) const;
+    optional<bool> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<float> {
-    optional<float> operator()(const Value& value, Error& error) const;
+    optional<float> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<std::string> {
-    optional<std::string> operator()(const Value& value, Error& error) const;
+    optional<std::string> operator()(const Convertible& value, Error& error) const;
 };
 
 template <class T>
 struct Converter<T, typename std::enable_if_t<std::is_enum<T>::value>> {
-    optional<T> operator()(const Value& value, Error& error) const {
+    optional<T> operator()(const Convertible& value, Error& error) const {
         optional<std::string> string = toString(value);
         if (!string) {
             error = { "value must be a string" };
@@ -49,12 +49,12 @@ struct Converter<T, typename std::enable_if_t<std::is_enum<T>::value>> {
 
 template <>
 struct Converter<Color> {
-    optional<Color> operator()(const Value& value, Error& error) const;
+    optional<Color> operator()(const Convertible& value, Error& error) const;
 };
 
 template <size_t N>
 struct Converter<std::array<float, N>> {
-    optional<std::array<float, N>> operator()(const Value& value, Error& error) const {
+    optional<std::array<float, N>> operator()(const Convertible& value, Error& error) const {
         if (!isArray(value) || arrayLength(value) != N) {
             error = { "value must be an array of " + util::toString(N) + " numbers" };
             return {};
@@ -75,12 +75,12 @@ struct Converter<std::array<float, N>> {
 
 template <>
 struct Converter<std::vector<float>> {
-    optional<std::vector<float>> operator()(const Value& value, Error& error) const;
+    optional<std::vector<float>> operator()(const Convertible& value, Error& error) const;
 };
 
 template <>
 struct Converter<std::vector<std::string>> {
-    optional<std::vector<std::string>> operator()(const Value& value, Error& error) const;
+    optional<std::vector<std::string>> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/coordinate.hpp b/include/mbgl/style/conversion/coordinate.hpp
index 8aa39283a80..e11db5e32f3 100644
--- a/include/mbgl/style/conversion/coordinate.hpp
+++ b/include/mbgl/style/conversion/coordinate.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template<>
 struct Converter<LatLng> {
 public:
-    optional<LatLng> operator() (const Value& value, Error& error) const;
+    optional<LatLng> operator() (const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index b7e3bef1725..1e54c15a493 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -11,7 +11,7 @@ namespace conversion {
 
 template <class T>
 struct Converter<DataDrivenPropertyValue<T>> {
-    optional<DataDrivenPropertyValue<T>> operator()(const Value& value, Error& error) const {
+    optional<DataDrivenPropertyValue<T>> operator()(const Convertible& value, Error& error) const {
         if (isUndefined(value)) {
             return DataDrivenPropertyValue<T>();
         } else if (!isObject(value)) {
diff --git a/include/mbgl/style/conversion/filter.hpp b/include/mbgl/style/conversion/filter.hpp
index d948ad01652..9daf6ea7a4e 100644
--- a/include/mbgl/style/conversion/filter.hpp
+++ b/include/mbgl/style/conversion/filter.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Filter> {
 public:
-    optional<Filter> operator()(const Value& value, Error& error) const;
+    optional<Filter> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/function.hpp b/include/mbgl/style/conversion/function.hpp
index 49dfacfef2e..e2308849442 100644
--- a/include/mbgl/style/conversion/function.hpp
+++ b/include/mbgl/style/conversion/function.hpp
@@ -12,7 +12,7 @@ namespace style {
 namespace conversion {
 
 template <class D, class R>
-optional<std::map<D, R>> convertStops(const Value& value, Error& error) {
+optional<std::map<D, R>> convertStops(const Convertible& value, Error& error) {
     auto stopsValue = objectMember(value, "stops");
     if (!stopsValue) {
         error = { "function value must specify stops" };
@@ -63,7 +63,7 @@ template <class T>
 struct Converter<ExponentialStops<T>> {
     static constexpr const char * type = "exponential";
 
-    optional<ExponentialStops<T>> operator()(const Value& value, Error& error) const {
+    optional<ExponentialStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<float, T>(value, error);
         if (!stops) {
             return {};
@@ -88,7 +88,7 @@ template <class T>
 struct Converter<IntervalStops<T>> {
     static constexpr const char * type = "interval";
 
-    optional<IntervalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<IntervalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<float, T>(value, error);
         if (!stops) {
             return {};
@@ -99,7 +99,7 @@ struct Converter<IntervalStops<T>> {
 
 template <>
 struct Converter<CategoricalValue> {
-    optional<CategoricalValue> operator()(const Value& value, Error& error) const {
+    optional<CategoricalValue> operator()(const Convertible& value, Error& error) const {
         auto b = toBool(value);
         if (b) {
             return { *b };
@@ -124,7 +124,7 @@ template <class T>
 struct Converter<CategoricalStops<T>> {
     static constexpr const char * type = "categorical";
 
-    optional<CategoricalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CategoricalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CategoricalValue, T>(value, error);
         if (!stops) {
             return {};
@@ -138,7 +138,7 @@ template <class T>
 struct Converter<IdentityStops<T>> {
     static constexpr const char * type = "identity";
 
-    optional<IdentityStops<T>> operator()(const Value&, Error&) const {
+    optional<IdentityStops<T>> operator()(const Convertible&, Error&) const {
         return IdentityStops<T>();
     }
 };
@@ -149,7 +149,7 @@ struct StopsConverter;
 template <class T, class... Ts>
 struct StopsConverter<T, variant<Ts...>> {
 public:
-    optional<variant<Ts...>> operator()(const Value& value, Error& error) const {
+    optional<variant<Ts...>> operator()(const Convertible& value, Error& error) const {
         std::string type = util::Interpolatable<T>::value ? "exponential" : "interval";
 
         auto typeValue = objectMember(value, "type");
@@ -187,7 +187,7 @@ struct StopsConverter<T, variant<Ts...>> {
 
 template <class T>
 struct Converter<CameraFunction<T>> {
-    optional<CameraFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<CameraFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
@@ -203,7 +203,7 @@ struct Converter<CameraFunction<T>> {
 };
 
 template <class T>
-optional<optional<T>> convertDefaultValue(const Value& value, Error& error) {
+optional<optional<T>> convertDefaultValue(const Convertible& value, Error& error) {
     auto defaultValueValue = objectMember(value, "default");
     if (!defaultValueValue) {
         return optional<T>();
@@ -220,7 +220,7 @@ optional<optional<T>> convertDefaultValue(const Value& value, Error& error) {
 
 template <class T>
 struct Converter<SourceFunction<T>> {
-    optional<SourceFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<SourceFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
@@ -259,7 +259,7 @@ struct CompositeValue : std::pair<float, S> {
 
 template <class S>
 struct Converter<CompositeValue<S>> {
-    optional<CompositeValue<S>> operator()(const Value& value, Error& error) const {
+    optional<CompositeValue<S>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "stop must be an object" };
             return {};
@@ -295,7 +295,7 @@ template <class T>
 struct Converter<CompositeExponentialStops<T>> {
     static constexpr const char * type = "exponential";
 
-    optional<CompositeExponentialStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeExponentialStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<float>, T>(value, error);
         if (!stops) {
             return {};
@@ -320,7 +320,7 @@ template <class T>
 struct Converter<CompositeIntervalStops<T>> {
     static constexpr const char * type = "interval";
 
-    optional<CompositeIntervalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeIntervalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<float>, T>(value, error);
         if (!stops) {
             return {};
@@ -339,7 +339,7 @@ template <class T>
 struct Converter<CompositeCategoricalStops<T>> {
     static constexpr const char * type = "categorical";
 
-    optional<CompositeCategoricalStops<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeCategoricalStops<T>> operator()(const Convertible& value, Error& error) const {
         auto stops = convertStops<CompositeValue<CategoricalValue>, T>(value, error);
         if (!stops) {
             return {};
@@ -356,7 +356,7 @@ struct Converter<CompositeCategoricalStops<T>> {
 
 template <class T>
 struct Converter<CompositeFunction<T>> {
-    optional<CompositeFunction<T>> operator()(const Value& value, Error& error) const {
+    optional<CompositeFunction<T>> operator()(const Convertible& value, Error& error) const {
         if (!isObject(value)) {
             error = { "function must be an object" };
             return {};
diff --git a/include/mbgl/style/conversion/geojson.hpp b/include/mbgl/style/conversion/geojson.hpp
index ed1e0d5fb0c..403c5f953b2 100644
--- a/include/mbgl/style/conversion/geojson.hpp
+++ b/include/mbgl/style/conversion/geojson.hpp
@@ -13,7 +13,7 @@ optional<GeoJSON> parseGeoJSON(const std::string&, Error&);
 template <>
 struct Converter<GeoJSON> {
 public:
-    optional<GeoJSON> operator()(const Value&, Error&) const;
+    optional<GeoJSON> operator()(const Convertible&, Error&) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/geojson_options.hpp b/include/mbgl/style/conversion/geojson_options.hpp
index e9a147a5cb9..3f625babb6f 100644
--- a/include/mbgl/style/conversion/geojson_options.hpp
+++ b/include/mbgl/style/conversion/geojson_options.hpp
@@ -9,7 +9,7 @@ namespace conversion {
 
 template <>
 struct Converter<GeoJSONOptions> {
-    optional<GeoJSONOptions> operator()(const Value& value, Error& error) const;
+    optional<GeoJSONOptions> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/layer.hpp b/include/mbgl/style/conversion/layer.hpp
index 32454bdde4e..1c0e2e2f07d 100644
--- a/include/mbgl/style/conversion/layer.hpp
+++ b/include/mbgl/style/conversion/layer.hpp
@@ -12,12 +12,12 @@ namespace conversion {
 template <>
 struct Converter<std::unique_ptr<Layer>> {
 public:
-    optional<std::unique_ptr<Layer>> operator()(const Value& value, Error& error) const;
+    optional<std::unique_ptr<Layer>> operator()(const Convertible& value, Error& error) const;
 };
 
-optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Value& value);
-optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Value& value);
-optional<Error> setPaintProperties(Layer& layer, const Value& value);
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Convertible& value);
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Convertible& value);
+optional<Error> setPaintProperties(Layer& layer, const Convertible& value);
 
 } // namespace conversion
 } // namespace style
diff --git a/include/mbgl/style/conversion/light.hpp b/include/mbgl/style/conversion/light.hpp
index 38b6991b564..289fca2e312 100644
--- a/include/mbgl/style/conversion/light.hpp
+++ b/include/mbgl/style/conversion/light.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Light> {
 public:
-    optional<Light> operator()(const Value& value, Error& error) const;
+    optional<Light> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/position.hpp b/include/mbgl/style/conversion/position.hpp
index 167cd313786..044c45862d0 100644
--- a/include/mbgl/style/conversion/position.hpp
+++ b/include/mbgl/style/conversion/position.hpp
@@ -9,7 +9,7 @@ namespace conversion {
 
 template <>
 struct Converter<Position> {
-    optional<Position> operator()(const Value& value, Error& error) const;
+    optional<Position> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 3780381b232..c7f971ec91f 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -11,7 +11,7 @@ namespace conversion {
 
 template <class T>
 struct Converter<PropertyValue<T>> {
-    optional<PropertyValue<T>> operator()(const Value& value, Error& error) const {
+    optional<PropertyValue<T>> operator()(const Convertible& value, Error& error) const {
         if (isUndefined(value)) {
             return PropertyValue<T>();
         } else if (isObject(value)) {
diff --git a/include/mbgl/style/conversion/source.hpp b/include/mbgl/style/conversion/source.hpp
index 0b9a273eb5b..2cf2e36da4e 100644
--- a/include/mbgl/style/conversion/source.hpp
+++ b/include/mbgl/style/conversion/source.hpp
@@ -12,7 +12,7 @@ namespace conversion {
 template <>
 struct Converter<std::unique_ptr<Source>> {
 public:
-    optional<std::unique_ptr<Source>> operator()(const Value& value, Error& error, const std::string& id) const;
+    optional<std::unique_ptr<Source>> operator()(const Convertible& value, Error& error, const std::string& id) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/tileset.hpp b/include/mbgl/style/conversion/tileset.hpp
index 25f4f27d819..1fb4acf70d7 100644
--- a/include/mbgl/style/conversion/tileset.hpp
+++ b/include/mbgl/style/conversion/tileset.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<Tileset> {
 public:
-    optional<Tileset> operator()(const Value& value, Error& error) const;
+    optional<Tileset> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/include/mbgl/style/conversion/transition_options.hpp b/include/mbgl/style/conversion/transition_options.hpp
index 173d4a84487..0563f39ac3c 100644
--- a/include/mbgl/style/conversion/transition_options.hpp
+++ b/include/mbgl/style/conversion/transition_options.hpp
@@ -10,7 +10,7 @@ namespace conversion {
 template <>
 struct Converter<TransitionOptions> {
 public:
-    optional<TransitionOptions> operator()(const Value& value, Error& error) const;
+    optional<TransitionOptions> operator()(const Convertible& value, Error& error) const;
 };
 
 } // namespace conversion
diff --git a/platform/android/src/style/android_conversion.hpp b/platform/android/src/style/android_conversion.hpp
index bc067fbc534..9b0ddbb50a3 100644
--- a/platform/android/src/style/android_conversion.hpp
+++ b/platform/android/src/style/android_conversion.hpp
@@ -15,7 +15,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<mbgl::android::Value> {
+class ConversionTraits<mbgl::android::Value> {
 public:
     static bool isUndefined(const mbgl::android::Value& value) {
         return value.isNull();
@@ -85,7 +85,7 @@ class ValueTraits<mbgl::android::Value> {
         }
     }
 
-    static optional<mbgl::Value> toValue(const mbgl::android::Value& value) {
+    static optional<Value> toValue(const mbgl::android::Value& value) {
         if (value.isNull()) {
             return {};
         } else if (value.isBool()) {
@@ -111,7 +111,7 @@ class ValueTraits<mbgl::android::Value> {
 
 template <class T, class...Args>
 optional<T> convert(const mbgl::android::Value& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/platform/android/src/style/conversion/url_or_tileset.hpp b/platform/android/src/style/conversion/url_or_tileset.hpp
index dae1209697d..f2ebce7bd1c 100644
--- a/platform/android/src/style/conversion/url_or_tileset.hpp
+++ b/platform/android/src/style/conversion/url_or_tileset.hpp
@@ -20,16 +20,16 @@ namespace android {
 inline variant<std::string, Tileset> convertURLOrTileset(const mbgl::android::Value& value) {
     using namespace mbgl::style::conversion;
 
-    const mbgl::style::conversion::Value converted(value);
-    if (isObject(converted)) {
+    const Convertible convertible(value);
+    if (isObject(convertible)) {
         Error error;
-        optional<Tileset> tileset = convert<Tileset>(converted, error);
+        optional<Tileset> tileset = convert<Tileset>(convertible, error);
         if (!tileset) {
             throw std::logic_error(error.message);
         }
         return { *tileset };
     } else {
-        return { *toString(converted) };
+        return { *toString(convertible) };
     }
 }
 
diff --git a/platform/darwin/src/MGLConversion.h b/platform/darwin/src/MGLConversion.h
index 584438e04c7..1edb387a991 100644
--- a/platform/darwin/src/MGLConversion.h
+++ b/platform/darwin/src/MGLConversion.h
@@ -14,7 +14,7 @@ class Holder {
 };
 
 template <>
-class ValueTraits<Holder> {
+class ConversionTraits<Holder> {
 public:
     static bool isUndefined(const Holder& holder) {
         const id value = holder.value;
@@ -140,8 +140,8 @@ class ValueTraits<Holder> {
     }
 };
 
-inline Value makeValue(const id value) {
-    return {Holder(value)};
+inline Convertible makeConvertible(const id value) {
+    return Convertible(Holder(value));
 }
 
 } // namespace conversion
diff --git a/platform/darwin/src/MGLStyleValue_Private.h b/platform/darwin/src/MGLStyleValue_Private.h
index a6da6017d42..5914e0a2aaf 100644
--- a/platform/darwin/src/MGLStyleValue_Private.h
+++ b/platform/darwin/src/MGLStyleValue_Private.h
@@ -126,7 +126,7 @@ class MGLStyleValueTransformer {
         } else if ([value isKindOfClass:[MGLStyleFunction class]]) {
             mbgl::style::conversion::Error error;
             auto result = mbgl::style::conversion::convert<mbgl::style::DataDrivenPropertyValue<MBGLType>>(
-                mbgl::style::conversion::makeValue(toRawStyleSpecValue((MGLStyleFunction<ObjCType> *) value)), error);
+                mbgl::style::conversion::makeConvertible(toRawStyleSpecValue((MGLStyleFunction<ObjCType> *) value)), error);
             NSCAssert(result, @(error.message.c_str()));
             return *result;
         } else {
diff --git a/platform/node/src/node_conversion.hpp b/platform/node/src/node_conversion.hpp
index 7db5b236429..04494eb142d 100644
--- a/platform/node/src/node_conversion.hpp
+++ b/platform/node/src/node_conversion.hpp
@@ -16,7 +16,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<v8::Local<v8::Value>> {
+class ConversionTraits<v8::Local<v8::Value>> {
 public:
     static bool isUndefined(const v8::Local<v8::Value>& value) {
         Nan::HandleScope scope;
@@ -105,7 +105,7 @@ class ValueTraits<v8::Local<v8::Value>> {
         return std::string(*Nan::Utf8String(value));
     }
 
-    static optional<mbgl::Value> toValue(const v8::Local<v8::Value>& value) {
+    static optional<Value> toValue(const v8::Local<v8::Value>& value) {
         if (value->IsFalse()) {
             return { false };
         } else if (value->IsTrue()) {
@@ -137,7 +137,7 @@ class ValueTraits<v8::Local<v8::Value>> {
 
 template <class T, class...Args>
 optional<T> convert(const v8::Local<v8::Value>& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index bd5ba7b1526..ade409048e5 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -748,7 +748,7 @@ void NodeMap::SetLayoutProperty(const Nan::FunctionCallbackInfo<v8::Value>& info
         return Nan::ThrowTypeError("Second argument must be a string");
     }
 
-    mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), Value(info[2]));
+    mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), Convertible(info[2]));
     if (error) {
         return Nan::ThrowTypeError(error->message.c_str());
     }
@@ -780,7 +780,7 @@ void NodeMap::SetPaintProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
         return Nan::ThrowTypeError("Second argument must be a string");
     }
 
-    mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), Value(info[2]));
+    mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), Convertible(info[2]));
     if (error) {
         return Nan::ThrowTypeError(error->message.c_str());
     }
diff --git a/platform/qt/src/qt_conversion.hpp b/platform/qt/src/qt_conversion.hpp
index 3f58147ca24..91d5d48c126 100644
--- a/platform/qt/src/qt_conversion.hpp
+++ b/platform/qt/src/qt_conversion.hpp
@@ -14,7 +14,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<QVariant> {
+class ConversionTraits<QVariant> {
 public:
     static bool isUndefined(const QVariant& value) {
         return value.isNull() || !value.isValid();
@@ -105,7 +105,7 @@ class ValueTraits<QVariant> {
         }
     }
 
-    static optional<mbgl::Value> toValue(const QVariant& value) {
+    static optional<Value> toValue(const QVariant& value) {
         if (value.type() == QVariant::Bool) {
             return { value.toBool() };
         } else if (value.type() == QVariant::String) {
@@ -140,7 +140,7 @@ class ValueTraits<QVariant> {
 
 template <class T, class...Args>
 optional<T> convert(const QVariant& value, Error& error, Args&&...args) {
-    return convert<T>(Value(value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/src/mbgl/style/conversion/constant.cpp b/src/mbgl/style/conversion/constant.cpp
index 43feb3380b4..e837c4e70bb 100644
--- a/src/mbgl/style/conversion/constant.cpp
+++ b/src/mbgl/style/conversion/constant.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<bool> Converter<bool>::operator()(const Value& value, Error& error) const {
+optional<bool> Converter<bool>::operator()(const Convertible& value, Error& error) const {
     optional<bool> converted = toBool(value);
     if (!converted) {
         error = { "value must be a boolean" };
@@ -13,7 +13,7 @@ optional<bool> Converter<bool>::operator()(const Value& value, Error& error) con
     return *converted;
 }
 
-optional<float> Converter<float>::operator()(const Value& value, Error& error) const {
+optional<float> Converter<float>::operator()(const Convertible& value, Error& error) const {
     optional<float> converted = toNumber(value);
     if (!converted) {
         error = { "value must be a number" };
@@ -22,7 +22,7 @@ optional<float> Converter<float>::operator()(const Value& value, Error& error) c
     return *converted;
 }
 
-optional<std::string> Converter<std::string>::operator()(const Value& value, Error& error) const {
+optional<std::string> Converter<std::string>::operator()(const Convertible& value, Error& error) const {
     optional<std::string> converted = toString(value);
     if (!converted) {
         error = { "value must be a string" };
@@ -31,7 +31,7 @@ optional<std::string> Converter<std::string>::operator()(const Value& value, Err
     return *converted;
 }
 
-optional<Color> Converter<Color>::operator()(const Value& value, Error& error) const {
+optional<Color> Converter<Color>::operator()(const Convertible& value, Error& error) const {
     optional<std::string> string = toString(value);
     if (!string) {
         error = { "value must be a string" };
@@ -47,7 +47,7 @@ optional<Color> Converter<Color>::operator()(const Value& value, Error& error) c
     return *color;
 }
 
-optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Value& value, Error& error) const {
+optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "value must be an array" };
         return {};
@@ -68,7 +68,7 @@ optional<std::vector<float>> Converter<std::vector<float>>::operator()(const Val
     return result;
 }
 
-optional<std::vector<std::string>> Converter<std::vector<std::string>>::operator()(const Value& value, Error& error) const {
+optional<std::vector<std::string>> Converter<std::vector<std::string>>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "value must be an array" };
         return {};
diff --git a/src/mbgl/style/conversion/coordinate.cpp b/src/mbgl/style/conversion/coordinate.cpp
index 4f92a9a963d..9b2be3381ec 100644
--- a/src/mbgl/style/conversion/coordinate.cpp
+++ b/src/mbgl/style/conversion/coordinate.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<LatLng> Converter<LatLng>::operator() (const Value& value, Error& error) const {
+optional<LatLng> Converter<LatLng>::operator() (const Convertible& value, Error& error) const {
     if (!isArray(value) || arrayLength(value) < 2 ) {
         error = { "coordinate array must contain numeric longitude and latitude values" };
         return {};
diff --git a/src/mbgl/style/conversion/filter.cpp b/src/mbgl/style/conversion/filter.cpp
index f3633d5ff72..bb7bb6ea980 100644
--- a/src/mbgl/style/conversion/filter.cpp
+++ b/src/mbgl/style/conversion/filter.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-static optional<mbgl::Value> normalizeValue(const optional<mbgl::Value>& value, Error& error) {
+static optional<Value> normalizeValue(const optional<Value>& value, Error& error) {
     if (!value) {
         error = { "filter expression value must be a boolean, number, or string" };
         return {};
@@ -14,7 +14,7 @@ static optional<mbgl::Value> normalizeValue(const optional<mbgl::Value>& value,
     }
 }
 
-static optional<FeatureType> toFeatureType(const Value& value, Error& error) {
+static optional<FeatureType> toFeatureType(const Convertible& value, Error& error) {
     optional<std::string> type = toString(value);
     if (!type) {
         error = { "value for $type filter must be a string" };
@@ -31,8 +31,8 @@ static optional<FeatureType> toFeatureType(const Value& value, Error& error) {
     }
 }
 
-static optional<FeatureIdentifier> toFeatureIdentifier(const Value& value, Error& error) {
-    optional<mbgl::Value> identifier = toValue(value);
+static optional<FeatureIdentifier> toFeatureIdentifier(const Convertible& value, Error& error) {
+    optional<Value> identifier = toValue(value);
     if (!identifier) {
         error = { "filter expression value must be a boolean, number, or string" };
         return {};
@@ -50,7 +50,7 @@ static optional<FeatureIdentifier> toFeatureIdentifier(const Value& value, Error
 }
 
 template <class FilterType, class IdentifierFilterType>
-optional<Filter> convertUnaryFilter(const Value& value, Error& error) {
+optional<Filter> convertUnaryFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 2) {
         error = { "filter expression must have 2 elements" };
         return {};
@@ -70,7 +70,7 @@ optional<Filter> convertUnaryFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType, class TypeFilterType, class IdentifierFilterType>
-optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
+optional<Filter> convertEqualityFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 3) {
         error = { "filter expression must have 3 elements" };
         return {};
@@ -99,7 +99,7 @@ optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
         return { IdentifierFilterType { *filterValue } };
 
     } else {
-        optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+        optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
         if (!filterValue) {
             return {};
         }
@@ -109,7 +109,7 @@ optional<Filter> convertEqualityFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType>
-optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
+optional<Filter> convertBinaryFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 3) {
         error = { "filter expression must have 3 elements" };
         return {};
@@ -121,7 +121,7 @@ optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
         return {};
     }
 
-    optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
+    optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, 2)), error);
     if (!filterValue) {
         return {};
     }
@@ -130,7 +130,7 @@ optional<Filter> convertBinaryFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType, class TypeFilterType, class IdentifierFilterType>
-optional<Filter> convertSetFilter(const Value& value, Error& error) {
+optional<Filter> convertSetFilter(const Convertible& value, Error& error) {
     if (arrayLength(value) < 2) {
         error = { "filter expression must at least 2 elements" };
         return {};
@@ -167,9 +167,9 @@ optional<Filter> convertSetFilter(const Value& value, Error& error) {
         return { IdentifierFilterType { std::move(values) } };
 
     } else {
-        std::vector<mbgl::Value> values;
+        std::vector<Value> values;
         for (std::size_t i = 2; i < arrayLength(value); ++i) {
-            optional<mbgl::Value> filterValue = normalizeValue(toValue(arrayMember(value, i)), error);
+            optional<Value> filterValue = normalizeValue(toValue(arrayMember(value, i)), error);
             if (!filterValue) {
                 return {};
             }
@@ -181,7 +181,7 @@ optional<Filter> convertSetFilter(const Value& value, Error& error) {
 }
 
 template <class FilterType>
-optional<Filter> convertCompoundFilter(const Value& value, Error& error) {
+optional<Filter> convertCompoundFilter(const Convertible& value, Error& error) {
     std::vector<Filter> filters;
     for (std::size_t i = 1; i < arrayLength(value); ++i) {
         optional<Filter> element = convert<Filter>(arrayMember(value, i), error);
@@ -194,7 +194,7 @@ optional<Filter> convertCompoundFilter(const Value& value, Error& error) {
     return { FilterType { std::move(filters) } };
 }
 
-optional<Filter> Converter<Filter>::operator()(const Value& value, Error& error) const {
+optional<Filter> Converter<Filter>::operator()(const Convertible& value, Error& error) const {
     if (!isArray(value)) {
         error = { "filter expression must be an array" };
         return {};
diff --git a/src/mbgl/style/conversion/geojson.cpp b/src/mbgl/style/conversion/geojson.cpp
index 3e7188502f0..e39a1a80ebc 100644
--- a/src/mbgl/style/conversion/geojson.cpp
+++ b/src/mbgl/style/conversion/geojson.cpp
@@ -5,7 +5,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<GeoJSON> Converter<GeoJSON>::operator()(const Value& value, Error& error) const {
+optional<GeoJSON> Converter<GeoJSON>::operator()(const Convertible& value, Error& error) const {
     return toGeoJSON(value, error);
 }
 
diff --git a/src/mbgl/style/conversion/geojson_options.cpp b/src/mbgl/style/conversion/geojson_options.cpp
index e3d42900912..a2c5ed88160 100644
--- a/src/mbgl/style/conversion/geojson_options.cpp
+++ b/src/mbgl/style/conversion/geojson_options.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<GeoJSONOptions> Converter<GeoJSONOptions>::operator()(const Value& value, Error& error) const {
+optional<GeoJSONOptions> Converter<GeoJSONOptions>::operator()(const Convertible& value, Error& error) const {
     GeoJSONOptions options;
 
     const auto minzoomValue = objectMember(value, "minzoom");
diff --git a/src/mbgl/style/conversion/layer.cpp b/src/mbgl/style/conversion/layer.cpp
index 129c39c4ea4..0ca582f8dce 100644
--- a/src/mbgl/style/conversion/layer.cpp
+++ b/src/mbgl/style/conversion/layer.cpp
@@ -14,7 +14,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Value& value) {
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const Convertible& value) {
     static const auto setters = makeLayoutPropertySetters();
     auto it = setters.find(name);
     if (it == setters.end()) {
@@ -23,7 +23,7 @@ optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const V
     return it->second(layer, value);
 }
 
-optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Value& value) {
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Convertible& value) {
     static const auto setters = makePaintPropertySetters();
     auto it = setters.find(name);
     if (it == setters.end()) {
@@ -32,18 +32,18 @@ optional<Error> setPaintProperty(Layer& layer, const std::string& name, const Va
     return it->second(layer, value);
 }
 
-optional<Error> setPaintProperties(Layer& layer, const Value& value) {
+optional<Error> setPaintProperties(Layer& layer, const Convertible& value) {
     auto paintValue = objectMember(value, "paint");
     if (!paintValue) {
         return {};
     }
-    return eachMember(*paintValue, [&] (const std::string& k, const Value& v) {
+    return eachMember(*paintValue, [&] (const std::string& k, const Convertible& v) {
         return setPaintProperty(layer, k, v);
     });
 }
 
 template <class LayerType>
-optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const Value& value, Error& error) {
+optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const Convertible& value, Error& error) {
     auto sourceValue = objectMember(value, "source");
     if (!sourceValue) {
         error = { "layer must have a source" };
@@ -80,7 +80,7 @@ optional<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const
     return { std::move(layer) };
 }
 
-static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const Value& value, Error& error) {
+static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const Convertible& value, Error& error) {
     auto sourceValue = objectMember(value, "source");
     if (!sourceValue) {
         error = { "layer must have a source" };
@@ -96,11 +96,11 @@ static optional<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id
     return { std::make_unique<RasterLayer>(id, *source) };
 }
 
-static optional<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const Value&, Error&) {
+static optional<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const Convertible&, Error&) {
     return { std::make_unique<BackgroundLayer>(id) };
 }
 
-optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(const Value& value, Error& error) const {
+optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "layer must be an object" };
         return {};
@@ -183,7 +183,7 @@ optional<std::unique_ptr<Layer>> Converter<std::unique_ptr<Layer>>::operator()(c
             error = { "layout must be an object" };
             return {};
         }
-        optional<Error> error_ = eachMember(*layoutValue, [&] (const std::string& k, const Value& v) {
+        optional<Error> error_ = eachMember(*layoutValue, [&] (const std::string& k, const Convertible& v) {
             return setLayoutProperty(*layer, k, v);
         });
         if (error_) {
diff --git a/src/mbgl/style/conversion/light.cpp b/src/mbgl/style/conversion/light.cpp
index f468bddcc12..f521f743868 100644
--- a/src/mbgl/style/conversion/light.cpp
+++ b/src/mbgl/style/conversion/light.cpp
@@ -7,7 +7,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Light> Converter<Light>::operator()(const Value& value, Error& error) const {
+optional<Light> Converter<Light>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "light must be an object" };
         return {};
diff --git a/src/mbgl/style/conversion/position.cpp b/src/mbgl/style/conversion/position.cpp
index fa6619fee3b..702d250dbf1 100644
--- a/src/mbgl/style/conversion/position.cpp
+++ b/src/mbgl/style/conversion/position.cpp
@@ -7,7 +7,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Position> Converter<Position>::operator()(const Value& value, Error& error) const {
+optional<Position> Converter<Position>::operator()(const Convertible& value, Error& error) const {
     optional<std::array<float, 3>> spherical = convert<std::array<float, 3>>(value, error);
 
     if (!spherical) {
diff --git a/src/mbgl/style/conversion/property_setter.hpp b/src/mbgl/style/conversion/property_setter.hpp
index ef8377fc127..9e382b9c38d 100644
--- a/src/mbgl/style/conversion/property_setter.hpp
+++ b/src/mbgl/style/conversion/property_setter.hpp
@@ -13,10 +13,10 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-using PropertySetter = optional<Error> (*) (Layer&, const Value&);
+using PropertySetter = optional<Error> (*) (Layer&, const Convertible&);
 
 template <class L, class PropertyValue, void (L::*setter)(PropertyValue)>
-optional<Error> setProperty(Layer& layer, const Value& value) {
+optional<Error> setProperty(Layer& layer, const Convertible& value) {
     auto* typedLayer = layer.as<L>();
     if (!typedLayer) {
         return Error { "layer doesn't support this property" };
@@ -33,7 +33,7 @@ optional<Error> setProperty(Layer& layer, const Value& value) {
 }
 
 template <class L, void (L::*setter)(const TransitionOptions&)>
-optional<Error> setTransition(Layer& layer, const Value& value) {
+optional<Error> setTransition(Layer& layer, const Convertible& value) {
     auto* typedLayer = layer.as<L>();
     if (!typedLayer) {
         return Error { "layer doesn't support this property" };
@@ -49,7 +49,7 @@ optional<Error> setTransition(Layer& layer, const Value& value) {
     return {};
 }
 
-inline optional<Error> setVisibility(Layer& layer, const Value& value) {
+inline optional<Error> setVisibility(Layer& layer, const Convertible& value) {
     if (isUndefined(value)) {
         layer.setVisibility(VisibilityType::Visible);
         return {};
diff --git a/src/mbgl/style/conversion/source.cpp b/src/mbgl/style/conversion/source.cpp
index f88d33fa4bc..c10d0babcf8 100644
--- a/src/mbgl/style/conversion/source.cpp
+++ b/src/mbgl/style/conversion/source.cpp
@@ -14,7 +14,7 @@ namespace style {
 namespace conversion {
 
 // A tile source can either specify a URL to TileJSON, or inline TileJSON.
-static optional<variant<std::string, Tileset>> convertURLOrTileset(const Value& value, Error& error) {
+static optional<variant<std::string, Tileset>> convertURLOrTileset(const Convertible& value, Error& error) {
     auto urlVal = objectMember(value, "url");
     if (!urlVal) {
         optional<Tileset> tileset = convert<Tileset>(value, error);
@@ -34,7 +34,7 @@ static optional<variant<std::string, Tileset>> convertURLOrTileset(const Value&
 }
 
 static optional<std::unique_ptr<Source>> convertRasterSource(const std::string& id,
-                                                             const Value& value,
+                                                             const Convertible& value,
                                                              Error& error) {
     optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
     if (!urlOrTileset) {
@@ -56,7 +56,7 @@ static optional<std::unique_ptr<Source>> convertRasterSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertVectorSource(const std::string& id,
-                                                             const Value& value,
+                                                             const Convertible& value,
                                                              Error& error) {
     optional<variant<std::string, Tileset>> urlOrTileset = convertURLOrTileset(value, error);
     if (!urlOrTileset) {
@@ -67,7 +67,7 @@ static optional<std::unique_ptr<Source>> convertVectorSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string& id,
-                                                              const Value& value,
+                                                              const Convertible& value,
                                                               Error& error) {
     auto dataValue = objectMember(value, "data");
     if (!dataValue) {
@@ -99,7 +99,7 @@ static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string&
 }
 
 static optional<std::unique_ptr<Source>> convertImageSource(const std::string& id,
-                                                            const Value& value,
+                                                            const Convertible& value,
                                                             Error& error) {
     auto urlValue = objectMember(value, "url");
     if (!urlValue) {
@@ -138,7 +138,7 @@ static optional<std::unique_ptr<Source>> convertImageSource(const std::string& i
     return { std::move(result) };
 }
 
-optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()(const Value& value, Error& error, const std::string& id) const {
+optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()(const Convertible& value, Error& error, const std::string& id) const {
     if (!isObject(value)) {
         error = { "source must be an object" };
         return {};
diff --git a/src/mbgl/style/conversion/stringify.hpp b/src/mbgl/style/conversion/stringify.hpp
index 42b694c8527..6ae6fede42d 100644
--- a/src/mbgl/style/conversion/stringify.hpp
+++ b/src/mbgl/style/conversion/stringify.hpp
@@ -98,8 +98,8 @@ void stringify(Writer& writer, const std::unordered_map<std::string, T>& m) {
 }
 
 template <class Writer>
-void stringify(Writer& writer, const mbgl::Value& v) {
-    mbgl::Value::visit(v, [&] (const auto& v_) { stringify(writer, v_); });
+void stringify(Writer& writer, const Value& v) {
+    Value::visit(v, [&] (const auto& v_) { stringify(writer, v_); });
 }
 
 template <class Writer>
diff --git a/src/mbgl/style/conversion/tileset.cpp b/src/mbgl/style/conversion/tileset.cpp
index 54a486cb969..b9383c41b81 100644
--- a/src/mbgl/style/conversion/tileset.cpp
+++ b/src/mbgl/style/conversion/tileset.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<Tileset> Converter<Tileset>::operator()(const Value& value, Error& error) const {
+optional<Tileset> Converter<Tileset>::operator()(const Convertible& value, Error& error) const {
     Tileset result;
 
     auto tiles = objectMember(value, "tiles");
diff --git a/src/mbgl/style/conversion/transition_options.cpp b/src/mbgl/style/conversion/transition_options.cpp
index caabe7ec887..8a60c5bfd8e 100644
--- a/src/mbgl/style/conversion/transition_options.cpp
+++ b/src/mbgl/style/conversion/transition_options.cpp
@@ -4,7 +4,7 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-optional<TransitionOptions> Converter<TransitionOptions>::operator()(const Value& value, Error& error) const {
+optional<TransitionOptions> Converter<TransitionOptions>::operator()(const Convertible& value, Error& error) const {
     if (!isObject(value)) {
         error = { "transition must be an object" };
         return {};
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index 23901f5dc93..10fce339860 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -258,7 +258,7 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
         }
 
         layer = reference->cloneRef(id);
-        conversion::setPaintProperties(*layer, conversion::Value(&value));
+        conversion::setPaintProperties(*layer, conversion::Convertible(&value));
     } else {
         conversion::Error error;
         optional<std::unique_ptr<Layer>> converted = conversion::convert<std::unique_ptr<Layer>>(value, error);
diff --git a/src/mbgl/style/rapidjson_conversion.hpp b/src/mbgl/style/rapidjson_conversion.hpp
index ae3ead24b06..967f1d829cb 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -11,7 +11,7 @@ namespace style {
 namespace conversion {
 
 template <>
-class ValueTraits<const JSValue*> {
+class ConversionTraits<const JSValue*> {
 public:
     static bool isUndefined(const JSValue* value) {
         return value->IsNull();
@@ -81,7 +81,7 @@ class ValueTraits<const JSValue*> {
         return {{ value->GetString(), value->GetStringLength() }};
     }
 
-    static optional<mbgl::Value> toValue(const JSValue* value) {
+    static optional<Value> toValue(const JSValue* value) {
         switch (value->GetType()) {
             case rapidjson::kNullType:
             case rapidjson::kFalseType:
@@ -115,7 +115,7 @@ class ValueTraits<const JSValue*> {
 
 template <class T, class...Args>
 optional<T> convert(const JSValue& value, Error& error, Args&&...args) {
-    return convert<T>(Value(&value), error, std::forward<Args>(args)...);
+    return convert<T>(Convertible(&value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion