From b6e5edc26844df6a5f1f6e34881826828d36ce6a Mon Sep 17 00:00:00 2001
From: John Firebaugh <john.firebaugh@gmail.com>
Date: Thu, 9 Feb 2017 12:36:40 -0800
Subject: [core] Restore support for *-transition properties

---
 include/mbgl/style/layers/background_layer.hpp     |  5 +++++
 include/mbgl/style/layers/circle_layer.hpp         | 12 ++++++++++++
 include/mbgl/style/layers/fill_extrusion_layer.hpp |  9 +++++++++
 include/mbgl/style/layers/fill_layer.hpp           |  9 +++++++++
 include/mbgl/style/layers/layer.hpp.ejs            |  3 +++
 include/mbgl/style/layers/line_layer.hpp           | 12 ++++++++++++
 include/mbgl/style/layers/raster_layer.hpp         |  9 +++++++++
 include/mbgl/style/layers/symbol_layer.hpp         | 16 ++++++++++++++++
 8 files changed, 75 insertions(+)

(limited to 'include/mbgl/style/layers')

diff --git a/include/mbgl/style/layers/background_layer.hpp b/include/mbgl/style/layers/background_layer.hpp
index 050cb67df6..94076931e7 100644
--- a/include/mbgl/style/layers/background_layer.hpp
+++ b/include/mbgl/style/layers/background_layer.hpp
@@ -12,6 +12,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class BackgroundLayer : public Layer {
 public:
     BackgroundLayer(const std::string& layerID);
@@ -22,14 +24,17 @@ public:
     static PropertyValue<Color> getDefaultBackgroundColor();
     PropertyValue<Color> getBackgroundColor(const optional<std::string>& klass = {}) const;
     void setBackgroundColor(PropertyValue<Color>, const optional<std::string>& klass = {});
+    void setBackgroundColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultBackgroundPattern();
     PropertyValue<std::string> getBackgroundPattern(const optional<std::string>& klass = {}) const;
     void setBackgroundPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
+    void setBackgroundPatternTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultBackgroundOpacity();
     PropertyValue<float> getBackgroundOpacity(const optional<std::string>& klass = {}) const;
     void setBackgroundOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setBackgroundOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/circle_layer.hpp b/include/mbgl/style/layers/circle_layer.hpp
index 8ffea9946f..35db4b3962 100644
--- a/include/mbgl/style/layers/circle_layer.hpp
+++ b/include/mbgl/style/layers/circle_layer.hpp
@@ -12,6 +12,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class CircleLayer : public Layer {
 public:
     CircleLayer(const std::string& layerID, const std::string& sourceID);
@@ -30,42 +32,52 @@ public:
     static DataDrivenPropertyValue<float> getDefaultCircleRadius();
     DataDrivenPropertyValue<float> getCircleRadius(const optional<std::string>& klass = {}) const;
     void setCircleRadius(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setCircleRadiusTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultCircleColor();
     DataDrivenPropertyValue<Color> getCircleColor(const optional<std::string>& klass = {}) const;
     void setCircleColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setCircleColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultCircleBlur();
     DataDrivenPropertyValue<float> getCircleBlur(const optional<std::string>& klass = {}) const;
     void setCircleBlur(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setCircleBlurTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultCircleOpacity();
     DataDrivenPropertyValue<float> getCircleOpacity(const optional<std::string>& klass = {}) const;
     void setCircleOpacity(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setCircleOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultCircleTranslate();
     PropertyValue<std::array<float, 2>> getCircleTranslate(const optional<std::string>& klass = {}) const;
     void setCircleTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setCircleTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultCircleTranslateAnchor();
     PropertyValue<TranslateAnchorType> getCircleTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setCircleTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<CirclePitchScaleType> getDefaultCirclePitchScale();
     PropertyValue<CirclePitchScaleType> getCirclePitchScale(const optional<std::string>& klass = {}) const;
     void setCirclePitchScale(PropertyValue<CirclePitchScaleType>, const optional<std::string>& klass = {});
+    void setCirclePitchScaleTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultCircleStrokeWidth();
     DataDrivenPropertyValue<float> getCircleStrokeWidth(const optional<std::string>& klass = {}) const;
     void setCircleStrokeWidth(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setCircleStrokeWidthTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultCircleStrokeColor();
     DataDrivenPropertyValue<Color> getCircleStrokeColor(const optional<std::string>& klass = {}) const;
     void setCircleStrokeColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setCircleStrokeColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultCircleStrokeOpacity();
     DataDrivenPropertyValue<float> getCircleStrokeOpacity(const optional<std::string>& klass = {}) const;
     void setCircleStrokeOpacity(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setCircleStrokeOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/fill_extrusion_layer.hpp b/include/mbgl/style/layers/fill_extrusion_layer.hpp
index 09a0040ff3..c19a4ee168 100644
--- a/include/mbgl/style/layers/fill_extrusion_layer.hpp
+++ b/include/mbgl/style/layers/fill_extrusion_layer.hpp
@@ -12,6 +12,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class FillExtrusionLayer : public Layer {
 public:
     FillExtrusionLayer(const std::string& layerID, const std::string& sourceID);
@@ -30,30 +32,37 @@ public:
     static PropertyValue<float> getDefaultFillExtrusionOpacity();
     PropertyValue<float> getFillExtrusionOpacity(const optional<std::string>& klass = {}) const;
     void setFillExtrusionOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setFillExtrusionOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultFillExtrusionColor();
     DataDrivenPropertyValue<Color> getFillExtrusionColor(const optional<std::string>& klass = {}) const;
     void setFillExtrusionColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setFillExtrusionColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultFillExtrusionTranslate();
     PropertyValue<std::array<float, 2>> getFillExtrusionTranslate(const optional<std::string>& klass = {}) const;
     void setFillExtrusionTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setFillExtrusionTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultFillExtrusionTranslateAnchor();
     PropertyValue<TranslateAnchorType> getFillExtrusionTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setFillExtrusionTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultFillExtrusionPattern();
     PropertyValue<std::string> getFillExtrusionPattern(const optional<std::string>& klass = {}) const;
     void setFillExtrusionPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
+    void setFillExtrusionPatternTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultFillExtrusionHeight();
     DataDrivenPropertyValue<float> getFillExtrusionHeight(const optional<std::string>& klass = {}) const;
     void setFillExtrusionHeight(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setFillExtrusionHeightTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultFillExtrusionBase();
     DataDrivenPropertyValue<float> getFillExtrusionBase(const optional<std::string>& klass = {}) const;
     void setFillExtrusionBase(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setFillExtrusionBaseTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/fill_layer.hpp b/include/mbgl/style/layers/fill_layer.hpp
index 079541ec39..c064eab350 100644
--- a/include/mbgl/style/layers/fill_layer.hpp
+++ b/include/mbgl/style/layers/fill_layer.hpp
@@ -12,6 +12,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class FillLayer : public Layer {
 public:
     FillLayer(const std::string& layerID, const std::string& sourceID);
@@ -30,30 +32,37 @@ public:
     static PropertyValue<bool> getDefaultFillAntialias();
     PropertyValue<bool> getFillAntialias(const optional<std::string>& klass = {}) const;
     void setFillAntialias(PropertyValue<bool>, const optional<std::string>& klass = {});
+    void setFillAntialiasTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultFillOpacity();
     DataDrivenPropertyValue<float> getFillOpacity(const optional<std::string>& klass = {}) const;
     void setFillOpacity(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setFillOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultFillColor();
     DataDrivenPropertyValue<Color> getFillColor(const optional<std::string>& klass = {}) const;
     void setFillColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setFillColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultFillOutlineColor();
     DataDrivenPropertyValue<Color> getFillOutlineColor(const optional<std::string>& klass = {}) const;
     void setFillOutlineColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setFillOutlineColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultFillTranslate();
     PropertyValue<std::array<float, 2>> getFillTranslate(const optional<std::string>& klass = {}) const;
     void setFillTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setFillTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultFillTranslateAnchor();
     PropertyValue<TranslateAnchorType> getFillTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setFillTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultFillPattern();
     PropertyValue<std::string> getFillPattern(const optional<std::string>& klass = {}) const;
     void setFillPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
+    void setFillPatternTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs
index 0c902de5af..d66eae8198 100644
--- a/include/mbgl/style/layers/layer.hpp.ejs
+++ b/include/mbgl/style/layers/layer.hpp.ejs
@@ -21,6 +21,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class <%- camelize(type) %>Layer : public Layer {
 public:
 <% if (type === 'background') { -%>
@@ -58,6 +60,7 @@ public:
     static <%- propertyValueType(property) %> getDefault<%- camelize(property.name) %>();
     <%- propertyValueType(property) %> get<%- camelize(property.name) %>(const optional<std::string>& klass = {}) const;
     void set<%- camelize(property.name) %>(<%- propertyValueType(property) %>, const optional<std::string>& klass = {});
+    void set<%- camelize(property.name) %>Transition(const TransitionOptions&, const optional<std::string>& klass = {});
 
 <% } -%>
     // Private implementation
diff --git a/include/mbgl/style/layers/line_layer.hpp b/include/mbgl/style/layers/line_layer.hpp
index c9413f1096..2ed269ae74 100644
--- a/include/mbgl/style/layers/line_layer.hpp
+++ b/include/mbgl/style/layers/line_layer.hpp
@@ -14,6 +14,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class LineLayer : public Layer {
 public:
     LineLayer(const std::string& layerID, const std::string& sourceID);
@@ -50,42 +52,52 @@ public:
     static DataDrivenPropertyValue<float> getDefaultLineOpacity();
     DataDrivenPropertyValue<float> getLineOpacity(const optional<std::string>& klass = {}) const;
     void setLineOpacity(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setLineOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<Color> getDefaultLineColor();
     DataDrivenPropertyValue<Color> getLineColor(const optional<std::string>& klass = {}) const;
     void setLineColor(DataDrivenPropertyValue<Color>, const optional<std::string>& klass = {});
+    void setLineColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultLineTranslate();
     PropertyValue<std::array<float, 2>> getLineTranslate(const optional<std::string>& klass = {}) const;
     void setLineTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setLineTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultLineTranslateAnchor();
     PropertyValue<TranslateAnchorType> getLineTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setLineTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultLineWidth();
     PropertyValue<float> getLineWidth(const optional<std::string>& klass = {}) const;
     void setLineWidth(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setLineWidthTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultLineGapWidth();
     DataDrivenPropertyValue<float> getLineGapWidth(const optional<std::string>& klass = {}) const;
     void setLineGapWidth(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setLineGapWidthTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultLineOffset();
     DataDrivenPropertyValue<float> getLineOffset(const optional<std::string>& klass = {}) const;
     void setLineOffset(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setLineOffsetTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static DataDrivenPropertyValue<float> getDefaultLineBlur();
     DataDrivenPropertyValue<float> getLineBlur(const optional<std::string>& klass = {}) const;
     void setLineBlur(DataDrivenPropertyValue<float>, const optional<std::string>& klass = {});
+    void setLineBlurTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::vector<float>> getDefaultLineDasharray();
     PropertyValue<std::vector<float>> getLineDasharray(const optional<std::string>& klass = {}) const;
     void setLineDasharray(PropertyValue<std::vector<float>>, const optional<std::string>& klass = {});
+    void setLineDasharrayTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultLinePattern();
     PropertyValue<std::string> getLinePattern(const optional<std::string>& klass = {}) const;
     void setLinePattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
+    void setLinePatternTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/raster_layer.hpp b/include/mbgl/style/layers/raster_layer.hpp
index e998abf12a..72665baa72 100644
--- a/include/mbgl/style/layers/raster_layer.hpp
+++ b/include/mbgl/style/layers/raster_layer.hpp
@@ -12,6 +12,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class RasterLayer : public Layer {
 public:
     RasterLayer(const std::string& layerID, const std::string& sourceID);
@@ -25,30 +27,37 @@ public:
     static PropertyValue<float> getDefaultRasterOpacity();
     PropertyValue<float> getRasterOpacity(const optional<std::string>& klass = {}) const;
     void setRasterOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterHueRotate();
     PropertyValue<float> getRasterHueRotate(const optional<std::string>& klass = {}) const;
     void setRasterHueRotate(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterHueRotateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterBrightnessMin();
     PropertyValue<float> getRasterBrightnessMin(const optional<std::string>& klass = {}) const;
     void setRasterBrightnessMin(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterBrightnessMinTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterBrightnessMax();
     PropertyValue<float> getRasterBrightnessMax(const optional<std::string>& klass = {}) const;
     void setRasterBrightnessMax(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterBrightnessMaxTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterSaturation();
     PropertyValue<float> getRasterSaturation(const optional<std::string>& klass = {}) const;
     void setRasterSaturation(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterSaturationTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterContrast();
     PropertyValue<float> getRasterContrast(const optional<std::string>& klass = {}) const;
     void setRasterContrast(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterContrastTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterFadeDuration();
     PropertyValue<float> getRasterFadeDuration(const optional<std::string>& klass = {}) const;
     void setRasterFadeDuration(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setRasterFadeDurationTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp
index 8826408e81..ad21a70698 100644
--- a/include/mbgl/style/layers/symbol_layer.hpp
+++ b/include/mbgl/style/layers/symbol_layer.hpp
@@ -14,6 +14,8 @@
 namespace mbgl {
 namespace style {
 
+class TransitionOptions;
+
 class SymbolLayer : public Layer {
 public:
     SymbolLayer(const std::string& layerID, const std::string& sourceID);
@@ -170,58 +172,72 @@ public:
     static PropertyValue<float> getDefaultIconOpacity();
     PropertyValue<float> getIconOpacity(const optional<std::string>& klass = {}) const;
     void setIconOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setIconOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultIconColor();
     PropertyValue<Color> getIconColor(const optional<std::string>& klass = {}) const;
     void setIconColor(PropertyValue<Color>, const optional<std::string>& klass = {});
+    void setIconColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultIconHaloColor();
     PropertyValue<Color> getIconHaloColor(const optional<std::string>& klass = {}) const;
     void setIconHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
+    void setIconHaloColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultIconHaloWidth();
     PropertyValue<float> getIconHaloWidth(const optional<std::string>& klass = {}) const;
     void setIconHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setIconHaloWidthTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultIconHaloBlur();
     PropertyValue<float> getIconHaloBlur(const optional<std::string>& klass = {}) const;
     void setIconHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setIconHaloBlurTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultIconTranslate();
     PropertyValue<std::array<float, 2>> getIconTranslate(const optional<std::string>& klass = {}) const;
     void setIconTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setIconTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultIconTranslateAnchor();
     PropertyValue<TranslateAnchorType> getIconTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setIconTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextOpacity();
     PropertyValue<float> getTextOpacity(const optional<std::string>& klass = {}) const;
     void setTextOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setTextOpacityTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultTextColor();
     PropertyValue<Color> getTextColor(const optional<std::string>& klass = {}) const;
     void setTextColor(PropertyValue<Color>, const optional<std::string>& klass = {});
+    void setTextColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultTextHaloColor();
     PropertyValue<Color> getTextHaloColor(const optional<std::string>& klass = {}) const;
     void setTextHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
+    void setTextHaloColorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextHaloWidth();
     PropertyValue<float> getTextHaloWidth(const optional<std::string>& klass = {}) const;
     void setTextHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setTextHaloWidthTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextHaloBlur();
     PropertyValue<float> getTextHaloBlur(const optional<std::string>& klass = {}) const;
     void setTextHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
+    void setTextHaloBlurTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultTextTranslate();
     PropertyValue<std::array<float, 2>> getTextTranslate(const optional<std::string>& klass = {}) const;
     void setTextTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
+    void setTextTranslateTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultTextTranslateAnchor();
     PropertyValue<TranslateAnchorType> getTextTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
+    void setTextTranslateAnchorTransition(const TransitionOptions&, const optional<std::string>& klass = {});
 
     // Private implementation
 
-- 
cgit v1.2.1