@maplibre/maplibre-react-native 8.6.0-beta.0

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/components/styles/RCTMGLStyleFactory.java

@@ -0,0 +1,2242 @@
+// DO NOT MODIFY
+// THIS FILE IS AUTOGENERATED
+
+package com.mapbox.rctmgl.components.styles;
+
+import com.mapbox.mapboxsdk.style.layers.BackgroundLayer;
+import com.mapbox.mapboxsdk.style.layers.CircleLayer;
+import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer;
+import com.mapbox.mapboxsdk.style.layers.FillLayer;
+import com.mapbox.mapboxsdk.style.layers.LineLayer;
+import com.mapbox.mapboxsdk.style.layers.PropertyFactory;
+import com.mapbox.mapboxsdk.style.layers.PropertyValue;
+import com.mapbox.mapboxsdk.style.layers.RasterLayer;
+import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
+import com.mapbox.mapboxsdk.style.layers.HeatmapLayer;
+import com.mapbox.mapboxsdk.style.layers.HillshadeLayer;
+import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+import com.mapbox.mapboxsdk.style.light.Light;
+import com.mapbox.mapboxsdk.style.light.Position;
+import com.mapbox.rctmgl.utils.DownloadMapImageTask;
+
+import java.util.List;
+
+public class RCTMGLStyleFactory {
+    public static final String VALUE_KEY = "value";
+    public static final String SHOULD_ADD_IMAGE_KEY = "shouldAddImage";
+
+    public static void setFillLayerStyle(final FillLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "fillAntialias":
+              RCTMGLStyleFactory.setFillAntialias(layer, styleValue);
+              break;
+            case "fillOpacity":
+              RCTMGLStyleFactory.setFillOpacity(layer, styleValue);
+              break;
+            case "fillOpacityTransition":
+              RCTMGLStyleFactory.setFillOpacityTransition(layer, styleValue);
+              break;
+            case "fillColor":
+              RCTMGLStyleFactory.setFillColor(layer, styleValue);
+              break;
+            case "fillColorTransition":
+              RCTMGLStyleFactory.setFillColorTransition(layer, styleValue);
+              break;
+            case "fillOutlineColor":
+              RCTMGLStyleFactory.setFillOutlineColor(layer, styleValue);
+              break;
+            case "fillOutlineColorTransition":
+              RCTMGLStyleFactory.setFillOutlineColorTransition(layer, styleValue);
+              break;
+            case "fillTranslate":
+              RCTMGLStyleFactory.setFillTranslate(layer, styleValue);
+              break;
+            case "fillTranslateTransition":
+              RCTMGLStyleFactory.setFillTranslateTransition(layer, styleValue);
+              break;
+            case "fillTranslateAnchor":
+              RCTMGLStyleFactory.setFillTranslateAnchor(layer, styleValue);
+              break;
+            case "fillPattern":
+              style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
+                  @Override
+                  public void onAllImagesLoaded() {
+                      RCTMGLStyleFactory.setFillPattern(layer, styleValue);
+                  }
+              });
+              break;
+            case "fillPatternTransition":
+              RCTMGLStyleFactory.setFillPatternTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setLineLayerStyle(final LineLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "lineCap":
+              RCTMGLStyleFactory.setLineCap(layer, styleValue);
+              break;
+            case "lineJoin":
+              RCTMGLStyleFactory.setLineJoin(layer, styleValue);
+              break;
+            case "lineMiterLimit":
+              RCTMGLStyleFactory.setLineMiterLimit(layer, styleValue);
+              break;
+            case "lineRoundLimit":
+              RCTMGLStyleFactory.setLineRoundLimit(layer, styleValue);
+              break;
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "lineOpacity":
+              RCTMGLStyleFactory.setLineOpacity(layer, styleValue);
+              break;
+            case "lineOpacityTransition":
+              RCTMGLStyleFactory.setLineOpacityTransition(layer, styleValue);
+              break;
+            case "lineColor":
+              RCTMGLStyleFactory.setLineColor(layer, styleValue);
+              break;
+            case "lineColorTransition":
+              RCTMGLStyleFactory.setLineColorTransition(layer, styleValue);
+              break;
+            case "lineTranslate":
+              RCTMGLStyleFactory.setLineTranslate(layer, styleValue);
+              break;
+            case "lineTranslateTransition":
+              RCTMGLStyleFactory.setLineTranslateTransition(layer, styleValue);
+              break;
+            case "lineTranslateAnchor":
+              RCTMGLStyleFactory.setLineTranslateAnchor(layer, styleValue);
+              break;
+            case "lineWidth":
+              RCTMGLStyleFactory.setLineWidth(layer, styleValue);
+              break;
+            case "lineWidthTransition":
+              RCTMGLStyleFactory.setLineWidthTransition(layer, styleValue);
+              break;
+            case "lineGapWidth":
+              RCTMGLStyleFactory.setLineGapWidth(layer, styleValue);
+              break;
+            case "lineGapWidthTransition":
+              RCTMGLStyleFactory.setLineGapWidthTransition(layer, styleValue);
+              break;
+            case "lineOffset":
+              RCTMGLStyleFactory.setLineOffset(layer, styleValue);
+              break;
+            case "lineOffsetTransition":
+              RCTMGLStyleFactory.setLineOffsetTransition(layer, styleValue);
+              break;
+            case "lineBlur":
+              RCTMGLStyleFactory.setLineBlur(layer, styleValue);
+              break;
+            case "lineBlurTransition":
+              RCTMGLStyleFactory.setLineBlurTransition(layer, styleValue);
+              break;
+            case "lineDasharray":
+              RCTMGLStyleFactory.setLineDasharray(layer, styleValue);
+              break;
+            case "lineDasharrayTransition":
+              RCTMGLStyleFactory.setLineDasharrayTransition(layer, styleValue);
+              break;
+            case "linePattern":
+              style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
+                  @Override
+                  public void onAllImagesLoaded() {
+                      RCTMGLStyleFactory.setLinePattern(layer, styleValue);
+                  }
+              });
+              break;
+            case "linePatternTransition":
+              RCTMGLStyleFactory.setLinePatternTransition(layer, styleValue);
+              break;
+            case "lineGradient":
+              RCTMGLStyleFactory.setLineGradient(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setSymbolLayerStyle(final SymbolLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "symbolPlacement":
+              RCTMGLStyleFactory.setSymbolPlacement(layer, styleValue);
+              break;
+            case "symbolSpacing":
+              RCTMGLStyleFactory.setSymbolSpacing(layer, styleValue);
+              break;
+            case "symbolAvoidEdges":
+              RCTMGLStyleFactory.setSymbolAvoidEdges(layer, styleValue);
+              break;
+            case "symbolSortKey":
+              RCTMGLStyleFactory.setSymbolSortKey(layer, styleValue);
+              break;
+            case "symbolZOrder":
+              RCTMGLStyleFactory.setSymbolZOrder(layer, styleValue);
+              break;
+            case "iconAllowOverlap":
+              RCTMGLStyleFactory.setIconAllowOverlap(layer, styleValue);
+              break;
+            case "iconIgnorePlacement":
+              RCTMGLStyleFactory.setIconIgnorePlacement(layer, styleValue);
+              break;
+            case "iconOptional":
+              RCTMGLStyleFactory.setIconOptional(layer, styleValue);
+              break;
+            case "iconRotationAlignment":
+              RCTMGLStyleFactory.setIconRotationAlignment(layer, styleValue);
+              break;
+            case "iconSize":
+              RCTMGLStyleFactory.setIconSize(layer, styleValue);
+              break;
+            case "iconTextFit":
+              RCTMGLStyleFactory.setIconTextFit(layer, styleValue);
+              break;
+            case "iconTextFitPadding":
+              RCTMGLStyleFactory.setIconTextFitPadding(layer, styleValue);
+              break;
+            case "iconImage":
+              style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
+                  @Override
+                  public void onAllImagesLoaded() {
+                      RCTMGLStyleFactory.setIconImage(layer, styleValue);
+                  }
+              });
+              break;
+            case "iconRotate":
+              RCTMGLStyleFactory.setIconRotate(layer, styleValue);
+              break;
+            case "iconPadding":
+              RCTMGLStyleFactory.setIconPadding(layer, styleValue);
+              break;
+            case "iconKeepUpright":
+              RCTMGLStyleFactory.setIconKeepUpright(layer, styleValue);
+              break;
+            case "iconOffset":
+              RCTMGLStyleFactory.setIconOffset(layer, styleValue);
+              break;
+            case "iconAnchor":
+              RCTMGLStyleFactory.setIconAnchor(layer, styleValue);
+              break;
+            case "iconPitchAlignment":
+              RCTMGLStyleFactory.setIconPitchAlignment(layer, styleValue);
+              break;
+            case "textPitchAlignment":
+              RCTMGLStyleFactory.setTextPitchAlignment(layer, styleValue);
+              break;
+            case "textRotationAlignment":
+              RCTMGLStyleFactory.setTextRotationAlignment(layer, styleValue);
+              break;
+            case "textField":
+              RCTMGLStyleFactory.setTextField(layer, styleValue);
+              break;
+            case "textFont":
+              RCTMGLStyleFactory.setTextFont(layer, styleValue);
+              break;
+            case "textSize":
+              RCTMGLStyleFactory.setTextSize(layer, styleValue);
+              break;
+            case "textMaxWidth":
+              RCTMGLStyleFactory.setTextMaxWidth(layer, styleValue);
+              break;
+            case "textLineHeight":
+              RCTMGLStyleFactory.setTextLineHeight(layer, styleValue);
+              break;
+            case "textLetterSpacing":
+              RCTMGLStyleFactory.setTextLetterSpacing(layer, styleValue);
+              break;
+            case "textJustify":
+              RCTMGLStyleFactory.setTextJustify(layer, styleValue);
+              break;
+            case "textRadialOffset":
+              RCTMGLStyleFactory.setTextRadialOffset(layer, styleValue);
+              break;
+            case "textVariableAnchor":
+              RCTMGLStyleFactory.setTextVariableAnchor(layer, styleValue);
+              break;
+            case "textAnchor":
+              RCTMGLStyleFactory.setTextAnchor(layer, styleValue);
+              break;
+            case "textMaxAngle":
+              RCTMGLStyleFactory.setTextMaxAngle(layer, styleValue);
+              break;
+            case "textWritingMode":
+              RCTMGLStyleFactory.setTextWritingMode(layer, styleValue);
+              break;
+            case "textRotate":
+              RCTMGLStyleFactory.setTextRotate(layer, styleValue);
+              break;
+            case "textPadding":
+              RCTMGLStyleFactory.setTextPadding(layer, styleValue);
+              break;
+            case "textKeepUpright":
+              RCTMGLStyleFactory.setTextKeepUpright(layer, styleValue);
+              break;
+            case "textTransform":
+              RCTMGLStyleFactory.setTextTransform(layer, styleValue);
+              break;
+            case "textOffset":
+              RCTMGLStyleFactory.setTextOffset(layer, styleValue);
+              break;
+            case "textAllowOverlap":
+              RCTMGLStyleFactory.setTextAllowOverlap(layer, styleValue);
+              break;
+            case "textIgnorePlacement":
+              RCTMGLStyleFactory.setTextIgnorePlacement(layer, styleValue);
+              break;
+            case "textOptional":
+              RCTMGLStyleFactory.setTextOptional(layer, styleValue);
+              break;
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "iconOpacity":
+              RCTMGLStyleFactory.setIconOpacity(layer, styleValue);
+              break;
+            case "iconOpacityTransition":
+              RCTMGLStyleFactory.setIconOpacityTransition(layer, styleValue);
+              break;
+            case "iconColor":
+              RCTMGLStyleFactory.setIconColor(layer, styleValue);
+              break;
+            case "iconColorTransition":
+              RCTMGLStyleFactory.setIconColorTransition(layer, styleValue);
+              break;
+            case "iconHaloColor":
+              RCTMGLStyleFactory.setIconHaloColor(layer, styleValue);
+              break;
+            case "iconHaloColorTransition":
+              RCTMGLStyleFactory.setIconHaloColorTransition(layer, styleValue);
+              break;
+            case "iconHaloWidth":
+              RCTMGLStyleFactory.setIconHaloWidth(layer, styleValue);
+              break;
+            case "iconHaloWidthTransition":
+              RCTMGLStyleFactory.setIconHaloWidthTransition(layer, styleValue);
+              break;
+            case "iconHaloBlur":
+              RCTMGLStyleFactory.setIconHaloBlur(layer, styleValue);
+              break;
+            case "iconHaloBlurTransition":
+              RCTMGLStyleFactory.setIconHaloBlurTransition(layer, styleValue);
+              break;
+            case "iconTranslate":
+              RCTMGLStyleFactory.setIconTranslate(layer, styleValue);
+              break;
+            case "iconTranslateTransition":
+              RCTMGLStyleFactory.setIconTranslateTransition(layer, styleValue);
+              break;
+            case "iconTranslateAnchor":
+              RCTMGLStyleFactory.setIconTranslateAnchor(layer, styleValue);
+              break;
+            case "textOpacity":
+              RCTMGLStyleFactory.setTextOpacity(layer, styleValue);
+              break;
+            case "textOpacityTransition":
+              RCTMGLStyleFactory.setTextOpacityTransition(layer, styleValue);
+              break;
+            case "textColor":
+              RCTMGLStyleFactory.setTextColor(layer, styleValue);
+              break;
+            case "textColorTransition":
+              RCTMGLStyleFactory.setTextColorTransition(layer, styleValue);
+              break;
+            case "textHaloColor":
+              RCTMGLStyleFactory.setTextHaloColor(layer, styleValue);
+              break;
+            case "textHaloColorTransition":
+              RCTMGLStyleFactory.setTextHaloColorTransition(layer, styleValue);
+              break;
+            case "textHaloWidth":
+              RCTMGLStyleFactory.setTextHaloWidth(layer, styleValue);
+              break;
+            case "textHaloWidthTransition":
+              RCTMGLStyleFactory.setTextHaloWidthTransition(layer, styleValue);
+              break;
+            case "textHaloBlur":
+              RCTMGLStyleFactory.setTextHaloBlur(layer, styleValue);
+              break;
+            case "textHaloBlurTransition":
+              RCTMGLStyleFactory.setTextHaloBlurTransition(layer, styleValue);
+              break;
+            case "textTranslate":
+              RCTMGLStyleFactory.setTextTranslate(layer, styleValue);
+              break;
+            case "textTranslateTransition":
+              RCTMGLStyleFactory.setTextTranslateTransition(layer, styleValue);
+              break;
+            case "textTranslateAnchor":
+              RCTMGLStyleFactory.setTextTranslateAnchor(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setCircleLayerStyle(final CircleLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "circleRadius":
+              RCTMGLStyleFactory.setCircleRadius(layer, styleValue);
+              break;
+            case "circleRadiusTransition":
+              RCTMGLStyleFactory.setCircleRadiusTransition(layer, styleValue);
+              break;
+            case "circleColor":
+              RCTMGLStyleFactory.setCircleColor(layer, styleValue);
+              break;
+            case "circleColorTransition":
+              RCTMGLStyleFactory.setCircleColorTransition(layer, styleValue);
+              break;
+            case "circleBlur":
+              RCTMGLStyleFactory.setCircleBlur(layer, styleValue);
+              break;
+            case "circleBlurTransition":
+              RCTMGLStyleFactory.setCircleBlurTransition(layer, styleValue);
+              break;
+            case "circleOpacity":
+              RCTMGLStyleFactory.setCircleOpacity(layer, styleValue);
+              break;
+            case "circleOpacityTransition":
+              RCTMGLStyleFactory.setCircleOpacityTransition(layer, styleValue);
+              break;
+            case "circleTranslate":
+              RCTMGLStyleFactory.setCircleTranslate(layer, styleValue);
+              break;
+            case "circleTranslateTransition":
+              RCTMGLStyleFactory.setCircleTranslateTransition(layer, styleValue);
+              break;
+            case "circleTranslateAnchor":
+              RCTMGLStyleFactory.setCircleTranslateAnchor(layer, styleValue);
+              break;
+            case "circlePitchScale":
+              RCTMGLStyleFactory.setCirclePitchScale(layer, styleValue);
+              break;
+            case "circlePitchAlignment":
+              RCTMGLStyleFactory.setCirclePitchAlignment(layer, styleValue);
+              break;
+            case "circleStrokeWidth":
+              RCTMGLStyleFactory.setCircleStrokeWidth(layer, styleValue);
+              break;
+            case "circleStrokeWidthTransition":
+              RCTMGLStyleFactory.setCircleStrokeWidthTransition(layer, styleValue);
+              break;
+            case "circleStrokeColor":
+              RCTMGLStyleFactory.setCircleStrokeColor(layer, styleValue);
+              break;
+            case "circleStrokeColorTransition":
+              RCTMGLStyleFactory.setCircleStrokeColorTransition(layer, styleValue);
+              break;
+            case "circleStrokeOpacity":
+              RCTMGLStyleFactory.setCircleStrokeOpacity(layer, styleValue);
+              break;
+            case "circleStrokeOpacityTransition":
+              RCTMGLStyleFactory.setCircleStrokeOpacityTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setHeatmapLayerStyle(final HeatmapLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "heatmapRadius":
+              RCTMGLStyleFactory.setHeatmapRadius(layer, styleValue);
+              break;
+            case "heatmapRadiusTransition":
+              RCTMGLStyleFactory.setHeatmapRadiusTransition(layer, styleValue);
+              break;
+            case "heatmapWeight":
+              RCTMGLStyleFactory.setHeatmapWeight(layer, styleValue);
+              break;
+            case "heatmapIntensity":
+              RCTMGLStyleFactory.setHeatmapIntensity(layer, styleValue);
+              break;
+            case "heatmapIntensityTransition":
+              RCTMGLStyleFactory.setHeatmapIntensityTransition(layer, styleValue);
+              break;
+            case "heatmapColor":
+              RCTMGLStyleFactory.setHeatmapColor(layer, styleValue);
+              break;
+            case "heatmapOpacity":
+              RCTMGLStyleFactory.setHeatmapOpacity(layer, styleValue);
+              break;
+            case "heatmapOpacityTransition":
+              RCTMGLStyleFactory.setHeatmapOpacityTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setFillExtrusionLayerStyle(final FillExtrusionLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "fillExtrusionOpacity":
+              RCTMGLStyleFactory.setFillExtrusionOpacity(layer, styleValue);
+              break;
+            case "fillExtrusionOpacityTransition":
+              RCTMGLStyleFactory.setFillExtrusionOpacityTransition(layer, styleValue);
+              break;
+            case "fillExtrusionColor":
+              RCTMGLStyleFactory.setFillExtrusionColor(layer, styleValue);
+              break;
+            case "fillExtrusionColorTransition":
+              RCTMGLStyleFactory.setFillExtrusionColorTransition(layer, styleValue);
+              break;
+            case "fillExtrusionTranslate":
+              RCTMGLStyleFactory.setFillExtrusionTranslate(layer, styleValue);
+              break;
+            case "fillExtrusionTranslateTransition":
+              RCTMGLStyleFactory.setFillExtrusionTranslateTransition(layer, styleValue);
+              break;
+            case "fillExtrusionTranslateAnchor":
+              RCTMGLStyleFactory.setFillExtrusionTranslateAnchor(layer, styleValue);
+              break;
+            case "fillExtrusionPattern":
+              style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
+                  @Override
+                  public void onAllImagesLoaded() {
+                      RCTMGLStyleFactory.setFillExtrusionPattern(layer, styleValue);
+                  }
+              });
+              break;
+            case "fillExtrusionPatternTransition":
+              RCTMGLStyleFactory.setFillExtrusionPatternTransition(layer, styleValue);
+              break;
+            case "fillExtrusionHeight":
+              RCTMGLStyleFactory.setFillExtrusionHeight(layer, styleValue);
+              break;
+            case "fillExtrusionHeightTransition":
+              RCTMGLStyleFactory.setFillExtrusionHeightTransition(layer, styleValue);
+              break;
+            case "fillExtrusionBase":
+              RCTMGLStyleFactory.setFillExtrusionBase(layer, styleValue);
+              break;
+            case "fillExtrusionBaseTransition":
+              RCTMGLStyleFactory.setFillExtrusionBaseTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setRasterLayerStyle(final RasterLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "rasterOpacity":
+              RCTMGLStyleFactory.setRasterOpacity(layer, styleValue);
+              break;
+            case "rasterOpacityTransition":
+              RCTMGLStyleFactory.setRasterOpacityTransition(layer, styleValue);
+              break;
+            case "rasterHueRotate":
+              RCTMGLStyleFactory.setRasterHueRotate(layer, styleValue);
+              break;
+            case "rasterHueRotateTransition":
+              RCTMGLStyleFactory.setRasterHueRotateTransition(layer, styleValue);
+              break;
+            case "rasterBrightnessMin":
+              RCTMGLStyleFactory.setRasterBrightnessMin(layer, styleValue);
+              break;
+            case "rasterBrightnessMinTransition":
+              RCTMGLStyleFactory.setRasterBrightnessMinTransition(layer, styleValue);
+              break;
+            case "rasterBrightnessMax":
+              RCTMGLStyleFactory.setRasterBrightnessMax(layer, styleValue);
+              break;
+            case "rasterBrightnessMaxTransition":
+              RCTMGLStyleFactory.setRasterBrightnessMaxTransition(layer, styleValue);
+              break;
+            case "rasterSaturation":
+              RCTMGLStyleFactory.setRasterSaturation(layer, styleValue);
+              break;
+            case "rasterSaturationTransition":
+              RCTMGLStyleFactory.setRasterSaturationTransition(layer, styleValue);
+              break;
+            case "rasterContrast":
+              RCTMGLStyleFactory.setRasterContrast(layer, styleValue);
+              break;
+            case "rasterContrastTransition":
+              RCTMGLStyleFactory.setRasterContrastTransition(layer, styleValue);
+              break;
+            case "rasterResampling":
+              RCTMGLStyleFactory.setRasterResampling(layer, styleValue);
+              break;
+            case "rasterFadeDuration":
+              RCTMGLStyleFactory.setRasterFadeDuration(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setHillshadeLayerStyle(final HillshadeLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "hillshadeIlluminationDirection":
+              RCTMGLStyleFactory.setHillshadeIlluminationDirection(layer, styleValue);
+              break;
+            case "hillshadeIlluminationAnchor":
+              RCTMGLStyleFactory.setHillshadeIlluminationAnchor(layer, styleValue);
+              break;
+            case "hillshadeExaggeration":
+              RCTMGLStyleFactory.setHillshadeExaggeration(layer, styleValue);
+              break;
+            case "hillshadeExaggerationTransition":
+              RCTMGLStyleFactory.setHillshadeExaggerationTransition(layer, styleValue);
+              break;
+            case "hillshadeShadowColor":
+              RCTMGLStyleFactory.setHillshadeShadowColor(layer, styleValue);
+              break;
+            case "hillshadeShadowColorTransition":
+              RCTMGLStyleFactory.setHillshadeShadowColorTransition(layer, styleValue);
+              break;
+            case "hillshadeHighlightColor":
+              RCTMGLStyleFactory.setHillshadeHighlightColor(layer, styleValue);
+              break;
+            case "hillshadeHighlightColorTransition":
+              RCTMGLStyleFactory.setHillshadeHighlightColorTransition(layer, styleValue);
+              break;
+            case "hillshadeAccentColor":
+              RCTMGLStyleFactory.setHillshadeAccentColor(layer, styleValue);
+              break;
+            case "hillshadeAccentColorTransition":
+              RCTMGLStyleFactory.setHillshadeAccentColorTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setBackgroundLayerStyle(final BackgroundLayer layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "visibility":
+              RCTMGLStyleFactory.setVisibility(layer, styleValue);
+              break;
+            case "backgroundColor":
+              RCTMGLStyleFactory.setBackgroundColor(layer, styleValue);
+              break;
+            case "backgroundColorTransition":
+              RCTMGLStyleFactory.setBackgroundColorTransition(layer, styleValue);
+              break;
+            case "backgroundPattern":
+              style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
+                  @Override
+                  public void onAllImagesLoaded() {
+                      RCTMGLStyleFactory.setBackgroundPattern(layer, styleValue);
+                  }
+              });
+              break;
+            case "backgroundPatternTransition":
+              RCTMGLStyleFactory.setBackgroundPatternTransition(layer, styleValue);
+              break;
+            case "backgroundOpacity":
+              RCTMGLStyleFactory.setBackgroundOpacity(layer, styleValue);
+              break;
+            case "backgroundOpacityTransition":
+              RCTMGLStyleFactory.setBackgroundOpacityTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+    public static void setLightLayerStyle(final Light layer, RCTMGLStyle style) {
+      List<String> styleKeys = style.getAllStyleKeys();
+
+      if (styleKeys.size() == 0) {
+        return;
+      }
+
+      for (String styleKey : styleKeys) {
+        final RCTMGLStyleValue styleValue = style.getStyleValueForKey(styleKey);
+
+        switch (styleKey) {
+            case "anchor":
+              RCTMGLStyleFactory.setAnchor(layer, styleValue);
+              break;
+            case "position":
+              RCTMGLStyleFactory.setPosition(layer, styleValue);
+              break;
+            case "positionTransition":
+              RCTMGLStyleFactory.setPositionTransition(layer, styleValue);
+              break;
+            case "color":
+              RCTMGLStyleFactory.setColor(layer, styleValue);
+              break;
+            case "colorTransition":
+              RCTMGLStyleFactory.setColorTransition(layer, styleValue);
+              break;
+            case "intensity":
+              RCTMGLStyleFactory.setIntensity(layer, styleValue);
+              break;
+            case "intensityTransition":
+              RCTMGLStyleFactory.setIntensityTransition(layer, styleValue);
+              break;
+        }
+      }
+    }
+
+    public static void setVisibility(FillLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setFillAntialias(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillAntialias(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillAntialias(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setFillOpacity(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillOpacityTransition(FillLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillOpacityTransition(transition);
+      }
+    }
+
+    public static void setFillColor(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillColorTransition(FillLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillColorTransition(transition);
+      }
+    }
+
+    public static void setFillOutlineColor(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillOutlineColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillOutlineColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillOutlineColorTransition(FillLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillOutlineColorTransition(transition);
+      }
+    }
+
+    public static void setFillTranslate(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillTranslateTransition(FillLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillTranslateTransition(transition);
+      }
+    }
+
+    public static void setFillTranslateAnchor(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setFillPattern(FillLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue()) {
+          layer.setProperties(PropertyFactory.fillPattern(styleValue.getImageStringValue()));
+        } else {
+          layer.setProperties(PropertyFactory.fillPattern(styleValue.getExpression()));
+        }
+      } else {
+        layer.setProperties(PropertyFactory.fillPattern(styleValue.getImageURI()));
+      }
+    }
+
+
+    public static void setFillPatternTransition(FillLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillPatternTransition(transition);
+      }
+    }
+
+    public static void setLineCap(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineCap(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineCap(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setLineJoin(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineJoin(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineJoin(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setLineMiterLimit(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineMiterLimit(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineMiterLimit(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setLineRoundLimit(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineRoundLimit(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineRoundLimit(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setVisibility(LineLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setLineOpacity(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineOpacityTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineOpacityTransition(transition);
+      }
+    }
+
+    public static void setLineColor(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineColorTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineColorTransition(transition);
+      }
+    }
+
+    public static void setLineTranslate(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineTranslateTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineTranslateTransition(transition);
+      }
+    }
+
+    public static void setLineTranslateAnchor(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setLineWidth(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineWidthTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineWidthTransition(transition);
+      }
+    }
+
+    public static void setLineGapWidth(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineGapWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineGapWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineGapWidthTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineGapWidthTransition(transition);
+      }
+    }
+
+    public static void setLineOffset(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineOffset(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineOffset(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineOffsetTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineOffsetTransition(transition);
+      }
+    }
+
+    public static void setLineBlur(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineBlur(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineBlur(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineBlurTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineBlurTransition(transition);
+      }
+    }
+
+    public static void setLineDasharray(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineDasharray(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineDasharray(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setLineDasharrayTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLineDasharrayTransition(transition);
+      }
+    }
+
+    public static void setLinePattern(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue()) {
+          layer.setProperties(PropertyFactory.linePattern(styleValue.getImageStringValue()));
+        } else {
+          layer.setProperties(PropertyFactory.linePattern(styleValue.getExpression()));
+        }
+      } else {
+        layer.setProperties(PropertyFactory.linePattern(styleValue.getImageURI()));
+      }
+    }
+
+
+    public static void setLinePatternTransition(LineLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setLinePatternTransition(transition);
+      }
+    }
+
+    public static void setLineGradient(LineLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.lineGradient(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.lineGradient(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+    public static void setSymbolPlacement(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.symbolPlacement(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.symbolPlacement(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setSymbolSpacing(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.symbolSpacing(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.symbolSpacing(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setSymbolAvoidEdges(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.symbolAvoidEdges(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.symbolAvoidEdges(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setSymbolSortKey(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.symbolSortKey(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.symbolSortKey(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setSymbolZOrder(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.symbolZOrder(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.symbolZOrder(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconAllowOverlap(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconAllowOverlap(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconAllowOverlap(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconIgnorePlacement(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconIgnorePlacement(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconIgnorePlacement(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconOptional(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconOptional(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconOptional(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconRotationAlignment(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconRotationAlignment(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconRotationAlignment(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconSize(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconSize(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconSize(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconTextFit(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconTextFit(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconTextFit(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconTextFitPadding(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconTextFitPadding(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconTextFitPadding(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconImage(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue()) {
+          layer.setProperties(PropertyFactory.iconImage(styleValue.getImageStringValue()));
+        } else {
+          layer.setProperties(PropertyFactory.iconImage(styleValue.getExpression()));
+        }
+      } else {
+        layer.setProperties(PropertyFactory.iconImage(styleValue.getImageURI()));
+      }
+    }
+
+    public static void setIconRotate(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconRotate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconRotate(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconPadding(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconPadding(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconPadding(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconKeepUpright(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconKeepUpright(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconKeepUpright(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconOffset(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconOffset(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconOffset(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconAnchor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setIconPitchAlignment(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconPitchAlignment(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconPitchAlignment(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextPitchAlignment(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textPitchAlignment(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textPitchAlignment(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextRotationAlignment(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textRotationAlignment(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textRotationAlignment(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextField(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textField(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textField(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextFont(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textFont(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textFont(styleValue.getStringArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextSize(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textSize(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textSize(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextMaxWidth(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textMaxWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textMaxWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextLineHeight(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textLineHeight(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textLineHeight(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextLetterSpacing(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textLetterSpacing(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textLetterSpacing(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextJustify(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textJustify(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textJustify(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextRadialOffset(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textRadialOffset(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textRadialOffset(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextVariableAnchor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textVariableAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textVariableAnchor(styleValue.getStringArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextAnchor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextMaxAngle(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textMaxAngle(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textMaxAngle(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextWritingMode(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textWritingMode(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textWritingMode(styleValue.getStringArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextRotate(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textRotate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textRotate(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextPadding(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textPadding(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textPadding(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextKeepUpright(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textKeepUpright(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textKeepUpright(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextTransform(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textTransform(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textTransform(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextOffset(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textOffset(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textOffset(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextAllowOverlap(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textAllowOverlap(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textAllowOverlap(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextIgnorePlacement(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textIgnorePlacement(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textIgnorePlacement(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextOptional(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textOptional(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textOptional(styleValue.getBoolean(VALUE_KEY)));
+      }
+    }
+
+    public static void setVisibility(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setIconOpacity(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconOpacityTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconOpacityTransition(transition);
+      }
+    }
+
+    public static void setIconColor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconColorTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconColorTransition(transition);
+      }
+    }
+
+    public static void setIconHaloColor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconHaloColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconHaloColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconHaloColorTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconHaloColorTransition(transition);
+      }
+    }
+
+    public static void setIconHaloWidth(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconHaloWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconHaloWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconHaloWidthTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconHaloWidthTransition(transition);
+      }
+    }
+
+    public static void setIconHaloBlur(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconHaloBlur(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconHaloBlur(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconHaloBlurTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconHaloBlurTransition(transition);
+      }
+    }
+
+    public static void setIconTranslate(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setIconTranslateTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIconTranslateTransition(transition);
+      }
+    }
+
+    public static void setIconTranslateAnchor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.iconTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.iconTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setTextOpacity(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextOpacityTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextOpacityTransition(transition);
+      }
+    }
+
+    public static void setTextColor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextColorTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextColorTransition(transition);
+      }
+    }
+
+    public static void setTextHaloColor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textHaloColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textHaloColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextHaloColorTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextHaloColorTransition(transition);
+      }
+    }
+
+    public static void setTextHaloWidth(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textHaloWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textHaloWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextHaloWidthTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextHaloWidthTransition(transition);
+      }
+    }
+
+    public static void setTextHaloBlur(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textHaloBlur(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textHaloBlur(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextHaloBlurTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextHaloBlurTransition(transition);
+      }
+    }
+
+    public static void setTextTranslate(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setTextTranslateTransition(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setTextTranslateTransition(transition);
+      }
+    }
+
+    public static void setTextTranslateAnchor(SymbolLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.textTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.textTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setVisibility(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setCircleRadius(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleRadius(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleRadius(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleRadiusTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleRadiusTransition(transition);
+      }
+    }
+
+    public static void setCircleColor(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleColorTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleColorTransition(transition);
+      }
+    }
+
+    public static void setCircleBlur(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleBlur(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleBlur(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleBlurTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleBlurTransition(transition);
+      }
+    }
+
+    public static void setCircleOpacity(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleOpacityTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleOpacityTransition(transition);
+      }
+    }
+
+    public static void setCircleTranslate(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleTranslateTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleTranslateTransition(transition);
+      }
+    }
+
+    public static void setCircleTranslateAnchor(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setCirclePitchScale(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circlePitchScale(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circlePitchScale(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setCirclePitchAlignment(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circlePitchAlignment(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circlePitchAlignment(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setCircleStrokeWidth(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleStrokeWidth(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleStrokeWidth(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleStrokeWidthTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleStrokeWidthTransition(transition);
+      }
+    }
+
+    public static void setCircleStrokeColor(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleStrokeColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleStrokeColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleStrokeColorTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleStrokeColorTransition(transition);
+      }
+    }
+
+    public static void setCircleStrokeOpacity(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.circleStrokeOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.circleStrokeOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setCircleStrokeOpacityTransition(CircleLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setCircleStrokeOpacityTransition(transition);
+      }
+    }
+
+    public static void setVisibility(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setHeatmapRadius(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.heatmapRadius(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.heatmapRadius(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHeatmapRadiusTransition(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHeatmapRadiusTransition(transition);
+      }
+    }
+
+    public static void setHeatmapWeight(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.heatmapWeight(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.heatmapWeight(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setHeatmapIntensity(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.heatmapIntensity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.heatmapIntensity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHeatmapIntensityTransition(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHeatmapIntensityTransition(transition);
+      }
+    }
+
+    public static void setHeatmapColor(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.heatmapColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.heatmapColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+    public static void setHeatmapOpacity(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.heatmapOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.heatmapOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHeatmapOpacityTransition(HeatmapLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHeatmapOpacityTransition(transition);
+      }
+    }
+
+    public static void setVisibility(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setFillExtrusionOpacity(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillExtrusionOpacityTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionOpacityTransition(transition);
+      }
+    }
+
+    public static void setFillExtrusionColor(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillExtrusionColorTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionColorTransition(transition);
+      }
+    }
+
+    public static void setFillExtrusionTranslate(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionTranslate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionTranslate(styleValue.getFloatArray(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillExtrusionTranslateTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionTranslateTransition(transition);
+      }
+    }
+
+    public static void setFillExtrusionTranslateAnchor(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionTranslateAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionTranslateAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setFillExtrusionPattern(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue()) {
+          layer.setProperties(PropertyFactory.fillExtrusionPattern(styleValue.getImageStringValue()));
+        } else {
+          layer.setProperties(PropertyFactory.fillExtrusionPattern(styleValue.getExpression()));
+        }
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionPattern(styleValue.getImageURI()));
+      }
+    }
+
+
+    public static void setFillExtrusionPatternTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionPatternTransition(transition);
+      }
+    }
+
+    public static void setFillExtrusionHeight(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionHeight(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionHeight(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillExtrusionHeightTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionHeightTransition(transition);
+      }
+    }
+
+    public static void setFillExtrusionBase(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.fillExtrusionBase(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.fillExtrusionBase(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setFillExtrusionBaseTransition(FillExtrusionLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setFillExtrusionBaseTransition(transition);
+      }
+    }
+
+    public static void setVisibility(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setRasterOpacity(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterOpacityTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterOpacityTransition(transition);
+      }
+    }
+
+    public static void setRasterHueRotate(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterHueRotate(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterHueRotate(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterHueRotateTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterHueRotateTransition(transition);
+      }
+    }
+
+    public static void setRasterBrightnessMin(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterBrightnessMin(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterBrightnessMin(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterBrightnessMinTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterBrightnessMinTransition(transition);
+      }
+    }
+
+    public static void setRasterBrightnessMax(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterBrightnessMax(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterBrightnessMax(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterBrightnessMaxTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterBrightnessMaxTransition(transition);
+      }
+    }
+
+    public static void setRasterSaturation(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterSaturation(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterSaturation(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterSaturationTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterSaturationTransition(transition);
+      }
+    }
+
+    public static void setRasterContrast(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterContrast(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterContrast(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setRasterContrastTransition(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setRasterContrastTransition(transition);
+      }
+    }
+
+    public static void setRasterResampling(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterResampling(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterResampling(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setRasterFadeDuration(RasterLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.rasterFadeDuration(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.rasterFadeDuration(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setVisibility(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setHillshadeIlluminationDirection(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeIlluminationDirection(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeIlluminationDirection(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+    public static void setHillshadeIlluminationAnchor(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeIlluminationAnchor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeIlluminationAnchor(styleValue.getString(VALUE_KEY)));
+      }
+    }
+
+    public static void setHillshadeExaggeration(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeExaggeration(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeExaggeration(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHillshadeExaggerationTransition(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHillshadeExaggerationTransition(transition);
+      }
+    }
+
+    public static void setHillshadeShadowColor(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeShadowColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeShadowColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHillshadeShadowColorTransition(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHillshadeShadowColorTransition(transition);
+      }
+    }
+
+    public static void setHillshadeHighlightColor(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeHighlightColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeHighlightColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHillshadeHighlightColorTransition(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHillshadeHighlightColorTransition(transition);
+      }
+    }
+
+    public static void setHillshadeAccentColor(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.hillshadeAccentColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.hillshadeAccentColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setHillshadeAccentColorTransition(HillshadeLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setHillshadeAccentColorTransition(transition);
+      }
+    }
+
+    public static void setVisibility(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      layer.setProperties(PropertyFactory.visibility(styleValue.getString(VALUE_KEY)));
+    }
+
+    public static void setBackgroundColor(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.backgroundColor(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.backgroundColor(styleValue.getInt(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setBackgroundColorTransition(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setBackgroundColorTransition(transition);
+      }
+    }
+
+    public static void setBackgroundPattern(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue()) {
+          layer.setProperties(PropertyFactory.backgroundPattern(styleValue.getImageStringValue()));
+        } else {
+          layer.setProperties(PropertyFactory.backgroundPattern(styleValue.getExpression()));
+        }
+      } else {
+        layer.setProperties(PropertyFactory.backgroundPattern(styleValue.getImageURI()));
+      }
+    }
+
+
+    public static void setBackgroundPatternTransition(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setBackgroundPatternTransition(transition);
+      }
+    }
+
+    public static void setBackgroundOpacity(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      if (styleValue.isExpression()) {
+        layer.setProperties(PropertyFactory.backgroundOpacity(styleValue.getExpression()));
+      } else {
+        layer.setProperties(PropertyFactory.backgroundOpacity(styleValue.getFloat(VALUE_KEY)));
+      }
+    }
+
+
+    public static void setBackgroundOpacityTransition(BackgroundLayer layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setBackgroundOpacityTransition(transition);
+      }
+    }
+
+    public static void setAnchor(Light layer, RCTMGLStyleValue styleValue) {
+      layer.setAnchor(styleValue.getString(VALUE_KEY));
+    }
+
+    public static void setPosition(Light layer, RCTMGLStyleValue styleValue) {
+      Float[] values = styleValue.getFloatArray(VALUE_KEY);
+      layer.setPosition(Position.fromPosition(values[0], values[1], values[2]));
+    }
+
+
+    public static void setPositionTransition(Light layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setPositionTransition(transition);
+      }
+    }
+
+    public static void setColor(Light layer, RCTMGLStyleValue styleValue) {
+      layer.setColor(styleValue.getInt(VALUE_KEY));
+    }
+
+
+    public static void setColorTransition(Light layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setColorTransition(transition);
+      }
+    }
+
+    public static void setIntensity(Light layer, RCTMGLStyleValue styleValue) {
+      layer.setIntensity(styleValue.getFloat(VALUE_KEY));
+    }
+
+
+    public static void setIntensityTransition(Light layer, RCTMGLStyleValue styleValue) {
+      TransitionOptions transition = styleValue.getTransition();
+      if (transition != null) {
+        layer.setIntensityTransition(transition);
+      }
+    }
+
+}