11 files changed, 2309 insertions, 4 deletions

diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index 66ab46c078..837d557722 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -149,5 +155,96 @@ TransitionOptions BackgroundLayer::getBackgroundOpacityTransition() const {
     return impl().paint.template get<BackgroundOpacity>().options;
 }
 
+using namespace conversion;
+
+optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "background-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setBackgroundColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "background-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setBackgroundColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "background-pattern") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setBackgroundPattern(*typedValue);
+        return nullopt;
+    }
+    if (name == "background-pattern-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setBackgroundPatternTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "background-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setBackgroundOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "background-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setBackgroundOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> BackgroundLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index d435ce89e1..3f769e935c 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/circle_layer.hpp>
 #include <mbgl/style/layers/circle_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -393,5 +399,264 @@ TransitionOptions CircleLayer::getCircleStrokeOpacityTransition() const {
     return impl().paint.template get<CircleStrokeOpacity>().options;
 }
 
+using namespace conversion;
+
+optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "circle-radius") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleRadius(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-radius-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleRadiusTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-blur") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleBlur(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-blur-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleBlurTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-pitch-scale") {
+        Error error;
+        optional<PropertyValue<CirclePitchScaleType>> typedValue = convert<PropertyValue<CirclePitchScaleType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCirclePitchScale(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-pitch-scale-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCirclePitchScaleTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-pitch-alignment") {
+        Error error;
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCirclePitchAlignment(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-pitch-alignment-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCirclePitchAlignmentTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-stroke-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleStrokeWidth(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-stroke-width-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleStrokeWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-stroke-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleStrokeColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-stroke-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleStrokeColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "circle-stroke-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setCircleStrokeOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "circle-stroke-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setCircleStrokeOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> CircleLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp
index 0e51a70e50..d1ac1a705c 100644
--- a/src/mbgl/style/layers/custom_layer.cpp
+++ b/src/mbgl/style/layers/custom_layer.cpp
@@ -50,6 +50,16 @@ void CustomLayer::setMaxZoom(float maxZoom) {
     baseImpl = std::move(impl_);
 }
 
+using namespace conversion;
+
+optional<Error> CustomLayer::setPaintProperty(const std::string&, const Convertible&) {
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> CustomLayer::setLayoutProperty(const std::string&, const Convertible&) {
+    return Error { "layer doesn't support this property" };
+}
+
 template <>
 bool Layer::is<CustomLayer>() const {
     return getType() == LayerType::Custom;
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index 829a24f354..b48e51c566 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/fill_extrusion_layer.hpp>
 #include <mbgl/style/layers/fill_extrusion_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -285,5 +291,180 @@ TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition() const {
     return impl().paint.template get<FillExtrusionBase>().options;
 }
 
+using namespace conversion;
+
+optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "fill-extrusion-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-pattern") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionPattern(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-pattern-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionPatternTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-height") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionHeight(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-height-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionHeightTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-extrusion-base") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillExtrusionBase(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-extrusion-base-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillExtrusionBaseTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> FillExtrusionLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 8eebd54e3c..04c3bcef3f 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/fill_layer.hpp>
 #include <mbgl/style/layers/fill_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -285,5 +291,180 @@ TransitionOptions FillLayer::getFillPatternTransition() const {
     return impl().paint.template get<FillPattern>().options;
 }
 
+using namespace conversion;
+
+optional<Error> FillLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "fill-antialias") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillAntialias(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-antialias-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillAntialiasTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-outline-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillOutlineColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-outline-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillOutlineColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "fill-pattern") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setFillPattern(*typedValue);
+        return nullopt;
+    }
+    if (name == "fill-pattern-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setFillPatternTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> FillLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/heatmap_layer.cpp b/src/mbgl/style/layers/heatmap_layer.cpp
index 21016ee509..443b94c2ce 100644
--- a/src/mbgl/style/layers/heatmap_layer.cpp
+++ b/src/mbgl/style/layers/heatmap_layer.cpp
@@ -3,9 +3,11 @@
 #include <mbgl/style/layers/heatmap_layer.hpp>
 #include <mbgl/style/layers/heatmap_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
-// for constructing default heatmap-color ramp expression from style JSON
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
@@ -237,5 +239,138 @@ TransitionOptions HeatmapLayer::getHeatmapOpacityTransition() const {
     return impl().paint.template get<HeatmapOpacity>().options;
 }
 
+using namespace conversion;
+
+optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "heatmap-radius") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHeatmapRadius(*typedValue);
+        return nullopt;
+    }
+    if (name == "heatmap-radius-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHeatmapRadiusTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "heatmap-weight") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHeatmapWeight(*typedValue);
+        return nullopt;
+    }
+    if (name == "heatmap-weight-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHeatmapWeightTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "heatmap-intensity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHeatmapIntensity(*typedValue);
+        return nullopt;
+    }
+    if (name == "heatmap-intensity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHeatmapIntensityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "heatmap-color") {
+        Error error;
+        optional<ColorRampPropertyValue> typedValue = convert<ColorRampPropertyValue>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHeatmapColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "heatmap-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHeatmapColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "heatmap-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHeatmapOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "heatmap-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHeatmapOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> HeatmapLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/hillshade_layer.cpp b/src/mbgl/style/layers/hillshade_layer.cpp
index e352ae090c..2d8c837baa 100644
--- a/src/mbgl/style/layers/hillshade_layer.cpp
+++ b/src/mbgl/style/layers/hillshade_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/hillshade_layer.hpp>
 #include <mbgl/style/layers/hillshade_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -236,5 +242,159 @@ TransitionOptions HillshadeLayer::getHillshadeAccentColorTransition() const {
     return impl().paint.template get<HillshadeAccentColor>().options;
 }
 
+using namespace conversion;
+
+optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "hillshade-illumination-direction") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeIlluminationDirection(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-illumination-direction-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeIlluminationDirectionTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "hillshade-illumination-anchor") {
+        Error error;
+        optional<PropertyValue<HillshadeIlluminationAnchorType>> typedValue = convert<PropertyValue<HillshadeIlluminationAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeIlluminationAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-illumination-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeIlluminationAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "hillshade-exaggeration") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeExaggeration(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-exaggeration-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeExaggerationTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "hillshade-shadow-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeShadowColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-shadow-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeShadowColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "hillshade-highlight-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeHighlightColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-highlight-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeHighlightColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "hillshade-accent-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setHillshadeAccentColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "hillshade-accent-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setHillshadeAccentColorTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> HillshadeLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index a9b6d9d02d..7555054bdb 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -8,12 +8,12 @@
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer.hpp>
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
-<% if (type === 'heatmap') { -%>
-// for constructing default heatmap-color ramp expression from style JSON
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
-<% } -%>
 
 namespace mbgl {
 namespace style {
@@ -175,5 +175,67 @@ TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>T
 }
 <% } -%>
 
+using namespace conversion;
+
+optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string& name, const Convertible& value) {
+    <% for (const property of paintProperties) { %>
+    if (name == "<%- property.name %>") {
+        Error error;
+        optional<<%- propertyValueType(property) %>> typedValue = convert<<%- propertyValueType(property) %>>(value, error, <%- property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven' %>, <%- property.name === 'icon-image' || property.name === 'text-field' %>);
+        if (!typedValue) {
+            return error;
+        }
+
+        set<%- camelize(property.name) %>(*typedValue);
+        return nullopt;
+    }
+    if (name == "<%- property.name %>-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        set<%- camelize(property.name) %>Transition(*transition);
+        return nullopt;
+    }
+    <% } -%>
+
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    <% for (const property of layoutProperties) { %>
+    if (name == "<%- property.name %>") {
+        Error error;
+        optional<<%- propertyValueType(property) %>> typedValue = convert<<%- propertyValueType(property) %>>(value, error, <%- property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven' %>, <%- property.name === 'icon-image' || property.name === 'text-field' %>);
+        if (!typedValue) {
+            return error;
+        }
+
+        set<%- camelize(property.name) %>(*typedValue);
+        return nullopt;
+    }
+    <% } -%>
+
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index 0cda849c0f..c3203f84e4 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -431,5 +437,287 @@ TransitionOptions LineLayer::getLinePatternTransition() const {
     return impl().paint.template get<LinePattern>().options;
 }
 
+using namespace conversion;
+
+optional<Error> LineLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "line-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineWidth(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-width-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-gap-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineGapWidth(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-gap-width-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineGapWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-offset") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineOffset(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-offset-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineOffsetTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-blur") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineBlur(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-blur-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineBlurTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-dasharray") {
+        Error error;
+        optional<PropertyValue<std::vector<float>>> typedValue = convert<PropertyValue<std::vector<float>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineDasharray(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-dasharray-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLineDasharrayTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "line-pattern") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLinePattern(*typedValue);
+        return nullopt;
+    }
+    if (name == "line-pattern-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setLinePatternTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    if (name == "line-cap") {
+        Error error;
+        optional<PropertyValue<LineCapType>> typedValue = convert<PropertyValue<LineCapType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineCap(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "line-join") {
+        Error error;
+        optional<PropertyValue<LineJoinType>> typedValue = convert<PropertyValue<LineJoinType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineJoin(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "line-miter-limit") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineMiterLimit(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "line-round-limit") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setLineRoundLimit(*typedValue);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index e5b03df0f6..0eba8ef886 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/raster_layer.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -290,5 +296,201 @@ TransitionOptions RasterLayer::getRasterFadeDurationTransition() const {
     return impl().paint.template get<RasterFadeDuration>().options;
 }
 
+using namespace conversion;
+
+optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "raster-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-hue-rotate") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterHueRotate(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-hue-rotate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterHueRotateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-brightness-min") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterBrightnessMin(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-brightness-min-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterBrightnessMinTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-brightness-max") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterBrightnessMax(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-brightness-max-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterBrightnessMaxTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-saturation") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterSaturation(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-saturation-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterSaturationTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-contrast") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterContrast(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-contrast-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterContrastTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-resampling") {
+        Error error;
+        optional<PropertyValue<RasterResamplingType>> typedValue = convert<PropertyValue<RasterResamplingType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterResampling(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-resampling-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterResamplingTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "raster-fade-duration") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setRasterFadeDuration(*typedValue);
+        return nullopt;
+    }
+    if (name == "raster-fade-duration-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setRasterFadeDurationTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> RasterLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index c416c6a6c5..bb5b317a38 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -3,6 +3,12 @@
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
 #include <mbgl/style/layer_observer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/color_ramp_property_value.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+#include <mbgl/style/conversion/json.hpp>
 
 namespace mbgl {
 namespace style {
@@ -1051,5 +1057,723 @@ TransitionOptions SymbolLayer::getTextTranslateAnchorTransition() const {
     return impl().paint.template get<TextTranslateAnchor>().options;
 }
 
+using namespace conversion;
+
+optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    
+    if (name == "icon-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-halo-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconHaloColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-halo-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconHaloColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-halo-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconHaloWidth(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-halo-width-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconHaloWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-halo-blur") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconHaloBlur(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-halo-blur-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconHaloBlurTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "icon-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "icon-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setIconTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-opacity") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextOpacity(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-opacity-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextOpacityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-halo-color") {
+        Error error;
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextHaloColor(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-halo-color-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextHaloColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-halo-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextHaloWidth(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-halo-width-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextHaloWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-halo-blur") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextHaloBlur(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-halo-blur-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextHaloBlurTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-translate") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextTranslate(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-translate-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextTranslateTransition(*transition);
+        return nullopt;
+    }
+    
+    if (name == "text-translate-anchor") {
+        Error error;
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextTranslateAnchor(*typedValue);
+        return nullopt;
+    }
+    if (name == "text-translate-anchor-transition") {
+        Error error;
+        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+        if (!transition) {
+            return error;
+        }
+
+        setTextTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
+optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Convertible& value) {
+    if (name == "visibility") {
+        if (isUndefined(value)) {
+            setVisibility(VisibilityType::Visible);
+            return nullopt;
+        }
+
+        Error error;
+        optional<VisibilityType> visibility = convert<VisibilityType>(value, error);
+        if (!visibility) {
+            return error;
+        }
+
+        setVisibility(*visibility);
+        return nullopt;
+    }
+
+    
+    if (name == "symbol-placement") {
+        Error error;
+        optional<PropertyValue<SymbolPlacementType>> typedValue = convert<PropertyValue<SymbolPlacementType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setSymbolPlacement(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "symbol-spacing") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setSymbolSpacing(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "symbol-avoid-edges") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setSymbolAvoidEdges(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-allow-overlap") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconAllowOverlap(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-ignore-placement") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconIgnorePlacement(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-optional") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconOptional(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-rotation-alignment") {
+        Error error;
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconRotationAlignment(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-size") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconSize(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-text-fit") {
+        Error error;
+        optional<PropertyValue<IconTextFitType>> typedValue = convert<PropertyValue<IconTextFitType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconTextFit(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-text-fit-padding") {
+        Error error;
+        optional<PropertyValue<std::array<float, 4>>> typedValue = convert<PropertyValue<std::array<float, 4>>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconTextFitPadding(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-image") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, true, true);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconImage(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-rotate") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconRotate(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-padding") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconPadding(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-keep-upright") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconKeepUpright(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-offset") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconOffset(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-anchor") {
+        Error error;
+        optional<PropertyValue<SymbolAnchorType>> typedValue = convert<PropertyValue<SymbolAnchorType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconAnchor(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "icon-pitch-alignment") {
+        Error error;
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setIconPitchAlignment(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-pitch-alignment") {
+        Error error;
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextPitchAlignment(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-rotation-alignment") {
+        Error error;
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextRotationAlignment(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-field") {
+        Error error;
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, true, true);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextField(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-font") {
+        Error error;
+        optional<PropertyValue<std::vector<std::string>>> typedValue = convert<PropertyValue<std::vector<std::string>>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextFont(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-size") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextSize(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-max-width") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextMaxWidth(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-line-height") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextLineHeight(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-letter-spacing") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextLetterSpacing(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-justify") {
+        Error error;
+        optional<PropertyValue<TextJustifyType>> typedValue = convert<PropertyValue<TextJustifyType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextJustify(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-anchor") {
+        Error error;
+        optional<PropertyValue<SymbolAnchorType>> typedValue = convert<PropertyValue<SymbolAnchorType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextAnchor(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-max-angle") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextMaxAngle(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-rotate") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextRotate(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-padding") {
+        Error error;
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextPadding(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-keep-upright") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextKeepUpright(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-transform") {
+        Error error;
+        optional<PropertyValue<TextTransformType>> typedValue = convert<PropertyValue<TextTransformType>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextTransform(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-offset") {
+        Error error;
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, true, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextOffset(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-allow-overlap") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextAllowOverlap(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-ignore-placement") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextIgnorePlacement(*typedValue);
+        return nullopt;
+    }
+    
+    if (name == "text-optional") {
+        Error error;
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        if (!typedValue) {
+            return error;
+        }
+
+        setTextOptional(*typedValue);
+        return nullopt;
+    }
+    
+    return Error { "layer doesn't support this property" };
+}
+
 } // namespace style
 } // namespace mbgl