@rnmapbox/maps 10.0.15 → 10.1.0-beta.4

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

@@ -0,0 +1,3669 @@
+// DO NOT MODIFY
+// THIS FILE IS AUTOGENERATED
+package com.mapbox.rctmgl.components.styles
+
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.layers.generated.BackgroundLayer
+import com.mapbox.maps.extension.style.layers.generated.CircleLayer
+import com.mapbox.maps.extension.style.layers.generated.FillExtrusionLayer
+import com.mapbox.maps.extension.style.layers.generated.FillLayer
+import com.mapbox.maps.extension.style.layers.generated.LineLayer
+import com.mapbox.maps.extension.style.layers.generated.SkyLayer
+// import com.mapbox.maps.extension.style.layers.generated.PropertyFactory
+// import com.mapbox.maps.extension.style.layers.generated.PropertyValue
+import com.mapbox.maps.extension.style.layers.generated.RasterLayer
+import com.mapbox.maps.extension.style.layers.generated.SymbolLayer
+import com.mapbox.maps.extension.style.layers.generated.HeatmapLayer
+import com.mapbox.maps.extension.style.layers.generated.HillshadeLayer
+import com.mapbox.maps.extension.style.atmosphere.generated.Atmosphere
+import com.mapbox.maps.extension.style.terrain.generated.Terrain
+// import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
+import com.mapbox.maps.extension.style.layers.properties.generated.*
+import com.mapbox.maps.extension.style.types.StyleTransition
+
+import com.mapbox.maps.extension.style.light.LightPosition
+import com.mapbox.rctmgl.utils.DownloadMapImageTask.OnAllImagesLoaded
+import com.mapbox.rctmgl.utils.Logger.e
+
+import com.mapbox.rctmgl.v11compat.light.*;
+
+import java.util.List;
+
+object RCTMGLStyleFactory {
+    const val VALUE_KEY = "value";
+    const val SHOULD_ADD_IMAGE_KEY = "shouldAddImage";
+
+    fun setFillLayerStyle(layer: FillLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "fillSortKey" ->
+              setFillSortKey(layer, styleValue)
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "fillAntialias" ->
+              setFillAntialias(layer, styleValue)
+            "fillOpacity" ->
+              setFillOpacity(layer, styleValue)
+              "fillOpacityTransition" ->
+              setFillOpacityTransition(layer, styleValue)
+            "fillColor" ->
+              setFillColor(layer, styleValue)
+              "fillColorTransition" ->
+              setFillColorTransition(layer, styleValue)
+            "fillOutlineColor" ->
+              setFillOutlineColor(layer, styleValue)
+              "fillOutlineColorTransition" ->
+              setFillOutlineColorTransition(layer, styleValue)
+            "fillTranslate" ->
+              setFillTranslate(layer, styleValue)
+              "fillTranslateTransition" ->
+              setFillTranslateTransition(layer, styleValue)
+            "fillTranslateAnchor" ->
+              setFillTranslateAnchor(layer, styleValue)
+            "fillPattern" ->
+              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
+                  override fun onAllImagesLoaded() {
+                      try {
+                          setFillPattern(layer, styleValue)
+                      } catch (exception: RuntimeException) {
+                          e("RCTMGLFill",String.format("Exception failed during setFillPattern: %s", exception.message))
+                      }
+                  }
+              })
+        }
+      }
+    }
+    fun setLineLayerStyle(layer: LineLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "lineCap" ->
+              setLineCap(layer, styleValue)
+            "lineJoin" ->
+              setLineJoin(layer, styleValue)
+            "lineMiterLimit" ->
+              setLineMiterLimit(layer, styleValue)
+            "lineRoundLimit" ->
+              setLineRoundLimit(layer, styleValue)
+            "lineSortKey" ->
+              setLineSortKey(layer, styleValue)
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "lineOpacity" ->
+              setLineOpacity(layer, styleValue)
+              "lineOpacityTransition" ->
+              setLineOpacityTransition(layer, styleValue)
+            "lineColor" ->
+              setLineColor(layer, styleValue)
+              "lineColorTransition" ->
+              setLineColorTransition(layer, styleValue)
+            "lineTranslate" ->
+              setLineTranslate(layer, styleValue)
+              "lineTranslateTransition" ->
+              setLineTranslateTransition(layer, styleValue)
+            "lineTranslateAnchor" ->
+              setLineTranslateAnchor(layer, styleValue)
+            "lineWidth" ->
+              setLineWidth(layer, styleValue)
+              "lineWidthTransition" ->
+              setLineWidthTransition(layer, styleValue)
+            "lineGapWidth" ->
+              setLineGapWidth(layer, styleValue)
+              "lineGapWidthTransition" ->
+              setLineGapWidthTransition(layer, styleValue)
+            "lineOffset" ->
+              setLineOffset(layer, styleValue)
+              "lineOffsetTransition" ->
+              setLineOffsetTransition(layer, styleValue)
+            "lineBlur" ->
+              setLineBlur(layer, styleValue)
+              "lineBlurTransition" ->
+              setLineBlurTransition(layer, styleValue)
+            "lineDasharray" ->
+              setLineDasharray(layer, styleValue)
+            "linePattern" ->
+              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
+                  override fun onAllImagesLoaded() {
+                      try {
+                          setLinePattern(layer, styleValue)
+                      } catch (exception: RuntimeException) {
+                          e("RCTMGLLine",String.format("Exception failed during setLinePattern: %s", exception.message))
+                      }
+                  }
+              })
+            "lineGradient" ->
+              setLineGradient(layer, styleValue)
+            "lineTrimOffset" ->
+              setLineTrimOffset(layer, styleValue)
+        }
+      }
+    }
+    fun setSymbolLayerStyle(layer: SymbolLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "symbolPlacement" ->
+              setSymbolPlacement(layer, styleValue)
+            "symbolSpacing" ->
+              setSymbolSpacing(layer, styleValue)
+            "symbolAvoidEdges" ->
+              setSymbolAvoidEdges(layer, styleValue)
+            "symbolSortKey" ->
+              setSymbolSortKey(layer, styleValue)
+            "symbolZOrder" ->
+              setSymbolZOrder(layer, styleValue)
+            "iconAllowOverlap" ->
+              setIconAllowOverlap(layer, styleValue)
+            "iconIgnorePlacement" ->
+              setIconIgnorePlacement(layer, styleValue)
+            "iconOptional" ->
+              setIconOptional(layer, styleValue)
+            "iconRotationAlignment" ->
+              setIconRotationAlignment(layer, styleValue)
+            "iconSize" ->
+              setIconSize(layer, styleValue)
+            "iconTextFit" ->
+              setIconTextFit(layer, styleValue)
+            "iconTextFitPadding" ->
+              setIconTextFitPadding(layer, styleValue)
+            "iconImage" ->
+              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
+                  override fun onAllImagesLoaded() {
+                      try {
+                          setIconImage(layer, styleValue)
+                      } catch (exception: RuntimeException) {
+                          e("RCTMGLSymbol",String.format("Exception failed during setIconImage: %s", exception.message))
+                      }
+                  }
+              })
+            "iconRotate" ->
+              setIconRotate(layer, styleValue)
+            "iconPadding" ->
+              setIconPadding(layer, styleValue)
+            "iconKeepUpright" ->
+              setIconKeepUpright(layer, styleValue)
+            "iconOffset" ->
+              setIconOffset(layer, styleValue)
+            "iconAnchor" ->
+              setIconAnchor(layer, styleValue)
+            "iconPitchAlignment" ->
+              setIconPitchAlignment(layer, styleValue)
+            "textPitchAlignment" ->
+              setTextPitchAlignment(layer, styleValue)
+            "textRotationAlignment" ->
+              setTextRotationAlignment(layer, styleValue)
+            "textField" ->
+              setTextField(layer, styleValue)
+            "textFont" ->
+              setTextFont(layer, styleValue)
+            "textSize" ->
+              setTextSize(layer, styleValue)
+            "textMaxWidth" ->
+              setTextMaxWidth(layer, styleValue)
+            "textLineHeight" ->
+              setTextLineHeight(layer, styleValue)
+            "textLetterSpacing" ->
+              setTextLetterSpacing(layer, styleValue)
+            "textJustify" ->
+              setTextJustify(layer, styleValue)
+            "textRadialOffset" ->
+              setTextRadialOffset(layer, styleValue)
+            "textVariableAnchor" ->
+              setTextVariableAnchor(layer, styleValue)
+            "textAnchor" ->
+              setTextAnchor(layer, styleValue)
+            "textMaxAngle" ->
+              setTextMaxAngle(layer, styleValue)
+            "textWritingMode" ->
+              setTextWritingMode(layer, styleValue)
+            "textRotate" ->
+              setTextRotate(layer, styleValue)
+            "textPadding" ->
+              setTextPadding(layer, styleValue)
+            "textKeepUpright" ->
+              setTextKeepUpright(layer, styleValue)
+            "textTransform" ->
+              setTextTransform(layer, styleValue)
+            "textOffset" ->
+              setTextOffset(layer, styleValue)
+            "textAllowOverlap" ->
+              setTextAllowOverlap(layer, styleValue)
+            "textIgnorePlacement" ->
+              setTextIgnorePlacement(layer, styleValue)
+            "textOptional" ->
+              setTextOptional(layer, styleValue)
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "iconOpacity" ->
+              setIconOpacity(layer, styleValue)
+              "iconOpacityTransition" ->
+              setIconOpacityTransition(layer, styleValue)
+            "iconColor" ->
+              setIconColor(layer, styleValue)
+              "iconColorTransition" ->
+              setIconColorTransition(layer, styleValue)
+            "iconHaloColor" ->
+              setIconHaloColor(layer, styleValue)
+              "iconHaloColorTransition" ->
+              setIconHaloColorTransition(layer, styleValue)
+            "iconHaloWidth" ->
+              setIconHaloWidth(layer, styleValue)
+              "iconHaloWidthTransition" ->
+              setIconHaloWidthTransition(layer, styleValue)
+            "iconHaloBlur" ->
+              setIconHaloBlur(layer, styleValue)
+              "iconHaloBlurTransition" ->
+              setIconHaloBlurTransition(layer, styleValue)
+            "iconTranslate" ->
+              setIconTranslate(layer, styleValue)
+              "iconTranslateTransition" ->
+              setIconTranslateTransition(layer, styleValue)
+            "iconTranslateAnchor" ->
+              setIconTranslateAnchor(layer, styleValue)
+            "textOpacity" ->
+              setTextOpacity(layer, styleValue)
+              "textOpacityTransition" ->
+              setTextOpacityTransition(layer, styleValue)
+            "textColor" ->
+              setTextColor(layer, styleValue)
+              "textColorTransition" ->
+              setTextColorTransition(layer, styleValue)
+            "textHaloColor" ->
+              setTextHaloColor(layer, styleValue)
+              "textHaloColorTransition" ->
+              setTextHaloColorTransition(layer, styleValue)
+            "textHaloWidth" ->
+              setTextHaloWidth(layer, styleValue)
+              "textHaloWidthTransition" ->
+              setTextHaloWidthTransition(layer, styleValue)
+            "textHaloBlur" ->
+              setTextHaloBlur(layer, styleValue)
+              "textHaloBlurTransition" ->
+              setTextHaloBlurTransition(layer, styleValue)
+            "textTranslate" ->
+              setTextTranslate(layer, styleValue)
+              "textTranslateTransition" ->
+              setTextTranslateTransition(layer, styleValue)
+            "textTranslateAnchor" ->
+              setTextTranslateAnchor(layer, styleValue)
+        }
+      }
+    }
+    fun setCircleLayerStyle(layer: CircleLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "circleSortKey" ->
+              setCircleSortKey(layer, styleValue)
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "circleRadius" ->
+              setCircleRadius(layer, styleValue)
+              "circleRadiusTransition" ->
+              setCircleRadiusTransition(layer, styleValue)
+            "circleColor" ->
+              setCircleColor(layer, styleValue)
+              "circleColorTransition" ->
+              setCircleColorTransition(layer, styleValue)
+            "circleBlur" ->
+              setCircleBlur(layer, styleValue)
+              "circleBlurTransition" ->
+              setCircleBlurTransition(layer, styleValue)
+            "circleOpacity" ->
+              setCircleOpacity(layer, styleValue)
+              "circleOpacityTransition" ->
+              setCircleOpacityTransition(layer, styleValue)
+            "circleTranslate" ->
+              setCircleTranslate(layer, styleValue)
+              "circleTranslateTransition" ->
+              setCircleTranslateTransition(layer, styleValue)
+            "circleTranslateAnchor" ->
+              setCircleTranslateAnchor(layer, styleValue)
+            "circlePitchScale" ->
+              setCirclePitchScale(layer, styleValue)
+            "circlePitchAlignment" ->
+              setCirclePitchAlignment(layer, styleValue)
+            "circleStrokeWidth" ->
+              setCircleStrokeWidth(layer, styleValue)
+              "circleStrokeWidthTransition" ->
+              setCircleStrokeWidthTransition(layer, styleValue)
+            "circleStrokeColor" ->
+              setCircleStrokeColor(layer, styleValue)
+              "circleStrokeColorTransition" ->
+              setCircleStrokeColorTransition(layer, styleValue)
+            "circleStrokeOpacity" ->
+              setCircleStrokeOpacity(layer, styleValue)
+              "circleStrokeOpacityTransition" ->
+              setCircleStrokeOpacityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setHeatmapLayerStyle(layer: HeatmapLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "heatmapRadius" ->
+              setHeatmapRadius(layer, styleValue)
+              "heatmapRadiusTransition" ->
+              setHeatmapRadiusTransition(layer, styleValue)
+            "heatmapWeight" ->
+              setHeatmapWeight(layer, styleValue)
+            "heatmapIntensity" ->
+              setHeatmapIntensity(layer, styleValue)
+              "heatmapIntensityTransition" ->
+              setHeatmapIntensityTransition(layer, styleValue)
+            "heatmapColor" ->
+              setHeatmapColor(layer, styleValue)
+            "heatmapOpacity" ->
+              setHeatmapOpacity(layer, styleValue)
+              "heatmapOpacityTransition" ->
+              setHeatmapOpacityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setFillExtrusionLayerStyle(layer: FillExtrusionLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "fillExtrusionOpacity" ->
+              setFillExtrusionOpacity(layer, styleValue)
+              "fillExtrusionOpacityTransition" ->
+              setFillExtrusionOpacityTransition(layer, styleValue)
+            "fillExtrusionColor" ->
+              setFillExtrusionColor(layer, styleValue)
+              "fillExtrusionColorTransition" ->
+              setFillExtrusionColorTransition(layer, styleValue)
+            "fillExtrusionTranslate" ->
+              setFillExtrusionTranslate(layer, styleValue)
+              "fillExtrusionTranslateTransition" ->
+              setFillExtrusionTranslateTransition(layer, styleValue)
+            "fillExtrusionTranslateAnchor" ->
+              setFillExtrusionTranslateAnchor(layer, styleValue)
+            "fillExtrusionPattern" ->
+              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
+                  override fun onAllImagesLoaded() {
+                      try {
+                          setFillExtrusionPattern(layer, styleValue)
+                      } catch (exception: RuntimeException) {
+                          e("RCTMGLFillExtrusion",String.format("Exception failed during setFillExtrusionPattern: %s", exception.message))
+                      }
+                  }
+              })
+            "fillExtrusionHeight" ->
+              setFillExtrusionHeight(layer, styleValue)
+              "fillExtrusionHeightTransition" ->
+              setFillExtrusionHeightTransition(layer, styleValue)
+            "fillExtrusionBase" ->
+              setFillExtrusionBase(layer, styleValue)
+              "fillExtrusionBaseTransition" ->
+              setFillExtrusionBaseTransition(layer, styleValue)
+            "fillExtrusionVerticalGradient" ->
+              setFillExtrusionVerticalGradient(layer, styleValue)
+        }
+      }
+    }
+    fun setRasterLayerStyle(layer: RasterLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "rasterOpacity" ->
+              setRasterOpacity(layer, styleValue)
+              "rasterOpacityTransition" ->
+              setRasterOpacityTransition(layer, styleValue)
+            "rasterHueRotate" ->
+              setRasterHueRotate(layer, styleValue)
+              "rasterHueRotateTransition" ->
+              setRasterHueRotateTransition(layer, styleValue)
+            "rasterBrightnessMin" ->
+              setRasterBrightnessMin(layer, styleValue)
+              "rasterBrightnessMinTransition" ->
+              setRasterBrightnessMinTransition(layer, styleValue)
+            "rasterBrightnessMax" ->
+              setRasterBrightnessMax(layer, styleValue)
+              "rasterBrightnessMaxTransition" ->
+              setRasterBrightnessMaxTransition(layer, styleValue)
+            "rasterSaturation" ->
+              setRasterSaturation(layer, styleValue)
+              "rasterSaturationTransition" ->
+              setRasterSaturationTransition(layer, styleValue)
+            "rasterContrast" ->
+              setRasterContrast(layer, styleValue)
+              "rasterContrastTransition" ->
+              setRasterContrastTransition(layer, styleValue)
+            "rasterResampling" ->
+              setRasterResampling(layer, styleValue)
+            "rasterFadeDuration" ->
+              setRasterFadeDuration(layer, styleValue)
+        }
+      }
+    }
+    fun setHillshadeLayerStyle(layer: HillshadeLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "hillshadeIlluminationDirection" ->
+              setHillshadeIlluminationDirection(layer, styleValue)
+            "hillshadeIlluminationAnchor" ->
+              setHillshadeIlluminationAnchor(layer, styleValue)
+            "hillshadeExaggeration" ->
+              setHillshadeExaggeration(layer, styleValue)
+              "hillshadeExaggerationTransition" ->
+              setHillshadeExaggerationTransition(layer, styleValue)
+            "hillshadeShadowColor" ->
+              setHillshadeShadowColor(layer, styleValue)
+              "hillshadeShadowColorTransition" ->
+              setHillshadeShadowColorTransition(layer, styleValue)
+            "hillshadeHighlightColor" ->
+              setHillshadeHighlightColor(layer, styleValue)
+              "hillshadeHighlightColorTransition" ->
+              setHillshadeHighlightColorTransition(layer, styleValue)
+            "hillshadeAccentColor" ->
+              setHillshadeAccentColor(layer, styleValue)
+              "hillshadeAccentColorTransition" ->
+              setHillshadeAccentColorTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setBackgroundLayerStyle(layer: BackgroundLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "backgroundColor" ->
+              setBackgroundColor(layer, styleValue)
+              "backgroundColorTransition" ->
+              setBackgroundColorTransition(layer, styleValue)
+            "backgroundPattern" ->
+              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
+                  override fun onAllImagesLoaded() {
+                      try {
+                          setBackgroundPattern(layer, styleValue)
+                      } catch (exception: RuntimeException) {
+                          e("RCTMGLBackground",String.format("Exception failed during setBackgroundPattern: %s", exception.message))
+                      }
+                  }
+              })
+            "backgroundOpacity" ->
+              setBackgroundOpacity(layer, styleValue)
+              "backgroundOpacityTransition" ->
+              setBackgroundOpacityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setSkyLayerStyle(layer: SkyLayer, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "visibility" ->
+              setVisibility(layer, styleValue)
+            "skyType" ->
+              setSkyType(layer, styleValue)
+            "skyAtmosphereSun" ->
+              setSkyAtmosphereSun(layer, styleValue)
+            "skyAtmosphereSunIntensity" ->
+              setSkyAtmosphereSunIntensity(layer, styleValue)
+            "skyGradientCenter" ->
+              setSkyGradientCenter(layer, styleValue)
+            "skyGradientRadius" ->
+              setSkyGradientRadius(layer, styleValue)
+            "skyGradient" ->
+              setSkyGradient(layer, styleValue)
+            "skyAtmosphereHaloColor" ->
+              setSkyAtmosphereHaloColor(layer, styleValue)
+            "skyAtmosphereColor" ->
+              setSkyAtmosphereColor(layer, styleValue)
+            "skyOpacity" ->
+              setSkyOpacity(layer, styleValue)
+              "skyOpacityTransition" ->
+              setSkyOpacityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setLightLayerStyle(layer: Light, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "anchor" ->
+              setAnchor(layer, styleValue)
+            "position" ->
+              setPosition(layer, styleValue)
+              "positionTransition" ->
+              setPositionTransition(layer, styleValue)
+            "color" ->
+              setColor(layer, styleValue)
+              "colorTransition" ->
+              setColorTransition(layer, styleValue)
+            "intensity" ->
+              setIntensity(layer, styleValue)
+              "intensityTransition" ->
+              setIntensityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setAtmosphereLayerStyle(layer: Atmosphere, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "range" ->
+              setRange(layer, styleValue)
+              "rangeTransition" ->
+              setRangeTransition(layer, styleValue)
+            "color" ->
+              setColor(layer, styleValue)
+              "colorTransition" ->
+              setColorTransition(layer, styleValue)
+            "highColor" ->
+              setHighColor(layer, styleValue)
+              "highColorTransition" ->
+              setHighColorTransition(layer, styleValue)
+            "spaceColor" ->
+              setSpaceColor(layer, styleValue)
+              "spaceColorTransition" ->
+              setSpaceColorTransition(layer, styleValue)
+            "horizonBlend" ->
+              setHorizonBlend(layer, styleValue)
+              "horizonBlendTransition" ->
+              setHorizonBlendTransition(layer, styleValue)
+            "starIntensity" ->
+              setStarIntensity(layer, styleValue)
+              "starIntensityTransition" ->
+              setStarIntensityTransition(layer, styleValue)
+        }
+      }
+    }
+    fun setTerrainLayerStyle(layer: Terrain, style: RCTMGLStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        val styleValue = style.getStyleValueForKey(styleKey)
+
+        when (styleKey) {
+            "exaggeration" ->
+              setExaggeration(layer, styleValue)
+        }
+      }
+    }
+
+    fun setFillSortKey(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillSortKey(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillSortKey is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.fillSortKey(value)
+          } else {
+            e("RCTMGLFill", "value for fillSortKey is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setFillAntialias(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillAntialias(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillAntialias is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.fillAntialias(value)
+          } else {
+            e("RCTMGLFill", "value for fillAntialias is null")
+          }
+      }
+    }
+
+    fun setFillOpacity(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillOpacity(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.fillOpacity(value)
+          } else {
+            e("RCTMGLFill", "value for fillOpacity is null")
+          }
+      }
+    }
+
+
+    fun setFillOpacityTransition(layer: FillLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillOpacityTransition(transition);
+      }
+    }
+
+    fun setFillColor(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillColor(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.fillColor(value)
+          } else {
+            e("RCTMGLFill", "value for fillColor is null")
+          }
+      }
+    }
+
+
+    fun setFillColorTransition(layer: FillLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillColorTransition(transition);
+      }
+    }
+
+    fun setFillOutlineColor(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillOutlineColor(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillOutlineColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.fillOutlineColor(value)
+          } else {
+            e("RCTMGLFill", "value for fillOutlineColor is null")
+          }
+      }
+    }
+
+
+    fun setFillOutlineColorTransition(layer: FillLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillOutlineColorTransition(transition);
+      }
+    }
+
+    fun setFillTranslate(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillTranslate(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.fillTranslate(value)
+          } else {
+            e("RCTMGLFill", "value for fillTranslate is null")
+          }
+      }
+    }
+
+
+    fun setFillTranslateTransition(layer: FillLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillTranslateTransition(transition);
+      }
+    }
+
+    fun setFillTranslateAnchor(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillTranslateAnchor(expression)
+        } else {
+          e("RCTMGLFill", "Expression for fillTranslateAnchor is null")
+        }
+      } else {
+          layer.fillTranslateAnchor(FillTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setFillPattern(layer: FillLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue) {
+          val value = styleValue.getImageStringValue()
+          if (value != null) {
+            layer.fillPattern(value)
+          } else {
+            e("RCTMGLFill", "Image for fillPattern is null")
+          }
+        } else {
+          val expression = styleValue.getExpression()
+          if (expression != null) {
+            layer.fillPattern(expression)
+          } else {
+            e("RCTMGLFill", "Expression for fillPattern is null")
+          }
+        }
+      } else {
+        val value = styleValue.imageURI
+        if (value != null) {
+          layer.fillPattern(value);
+        } else {
+          e("RCTMGLFill", "value for fillPattern is null")
+        }
+      }
+    }
+
+    fun setLineCap(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineCap(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineCap is null")
+        }
+      } else {
+          layer.lineCap(LineCap.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setLineJoin(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineJoin(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineJoin is null")
+        }
+      } else {
+          layer.lineJoin(LineJoin.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setLineMiterLimit(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineMiterLimit(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineMiterLimit is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineMiterLimit(value)
+          } else {
+            e("RCTMGLLine", "value for lineMiterLimit is null")
+          }
+      }
+    }
+
+    fun setLineRoundLimit(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineRoundLimit(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineRoundLimit is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineRoundLimit(value)
+          } else {
+            e("RCTMGLLine", "value for lineRoundLimit is null")
+          }
+      }
+    }
+
+    fun setLineSortKey(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineSortKey(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineSortKey is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineSortKey(value)
+          } else {
+            e("RCTMGLLine", "value for lineSortKey is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setLineOpacity(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineOpacity(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineOpacity(value)
+          } else {
+            e("RCTMGLLine", "value for lineOpacity is null")
+          }
+      }
+    }
+
+
+    fun setLineOpacityTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineOpacityTransition(transition);
+      }
+    }
+
+    fun setLineColor(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineColor(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.lineColor(value)
+          } else {
+            e("RCTMGLLine", "value for lineColor is null")
+          }
+      }
+    }
+
+
+    fun setLineColorTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineColorTransition(transition);
+      }
+    }
+
+    fun setLineTranslate(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineTranslate(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.lineTranslate(value)
+          } else {
+            e("RCTMGLLine", "value for lineTranslate is null")
+          }
+      }
+    }
+
+
+    fun setLineTranslateTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineTranslateTransition(transition);
+      }
+    }
+
+    fun setLineTranslateAnchor(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineTranslateAnchor(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineTranslateAnchor is null")
+        }
+      } else {
+          layer.lineTranslateAnchor(LineTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setLineWidth(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineWidth(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineWidth(value)
+          } else {
+            e("RCTMGLLine", "value for lineWidth is null")
+          }
+      }
+    }
+
+
+    fun setLineWidthTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineWidthTransition(transition);
+      }
+    }
+
+    fun setLineGapWidth(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineGapWidth(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineGapWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineGapWidth(value)
+          } else {
+            e("RCTMGLLine", "value for lineGapWidth is null")
+          }
+      }
+    }
+
+
+    fun setLineGapWidthTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineGapWidthTransition(transition);
+      }
+    }
+
+    fun setLineOffset(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineOffset(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineOffset is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineOffset(value)
+          } else {
+            e("RCTMGLLine", "value for lineOffset is null")
+          }
+      }
+    }
+
+
+    fun setLineOffsetTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineOffsetTransition(transition);
+      }
+    }
+
+    fun setLineBlur(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineBlur(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineBlur is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.lineBlur(value)
+          } else {
+            e("RCTMGLLine", "value for lineBlur is null")
+          }
+      }
+    }
+
+
+    fun setLineBlurTransition(layer: LineLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.lineBlurTransition(transition);
+      }
+    }
+
+    fun setLineDasharray(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineDasharray(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineDasharray is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.lineDasharray(value)
+          } else {
+            e("RCTMGLLine", "value for lineDasharray is null")
+          }
+      }
+    }
+
+    fun setLinePattern(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue) {
+          val value = styleValue.getImageStringValue()
+          if (value != null) {
+            layer.linePattern(value)
+          } else {
+            e("RCTMGLLine", "Image for linePattern is null")
+          }
+        } else {
+          val expression = styleValue.getExpression()
+          if (expression != null) {
+            layer.linePattern(expression)
+          } else {
+            e("RCTMGLLine", "Expression for linePattern is null")
+          }
+        }
+      } else {
+        val value = styleValue.imageURI
+        if (value != null) {
+          layer.linePattern(value);
+        } else {
+          e("RCTMGLLine", "value for linePattern is null")
+        }
+      }
+    }
+
+    fun setLineGradient(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineGradient(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineGradient is null")
+        }
+      } else {
+          layer.lineGradient(styleValue.getIntExpression(VALUE_KEY))
+      }
+    }
+
+    fun setLineTrimOffset(layer: LineLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.lineTrimOffset(expression)
+        } else {
+          e("RCTMGLLine", "Expression for lineTrimOffset is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.lineTrimOffset(value)
+          } else {
+            e("RCTMGLLine", "value for lineTrimOffset is null")
+          }
+      }
+    }
+
+    fun setSymbolPlacement(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.symbolPlacement(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for symbolPlacement is null")
+        }
+      } else {
+          layer.symbolPlacement(SymbolPlacement.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setSymbolSpacing(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.symbolSpacing(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for symbolSpacing is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.symbolSpacing(value)
+          } else {
+            e("RCTMGLSymbol", "value for symbolSpacing is null")
+          }
+      }
+    }
+
+    fun setSymbolAvoidEdges(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.symbolAvoidEdges(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for symbolAvoidEdges is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.symbolAvoidEdges(value)
+          } else {
+            e("RCTMGLSymbol", "value for symbolAvoidEdges is null")
+          }
+      }
+    }
+
+    fun setSymbolSortKey(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.symbolSortKey(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for symbolSortKey is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.symbolSortKey(value)
+          } else {
+            e("RCTMGLSymbol", "value for symbolSortKey is null")
+          }
+      }
+    }
+
+    fun setSymbolZOrder(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.symbolZOrder(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for symbolZOrder is null")
+        }
+      } else {
+          layer.symbolZOrder(SymbolZOrder.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setIconAllowOverlap(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconAllowOverlap(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconAllowOverlap is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.iconAllowOverlap(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconAllowOverlap is null")
+          }
+      }
+    }
+
+    fun setIconIgnorePlacement(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconIgnorePlacement(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconIgnorePlacement is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.iconIgnorePlacement(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconIgnorePlacement is null")
+          }
+      }
+    }
+
+    fun setIconOptional(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconOptional(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconOptional is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.iconOptional(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconOptional is null")
+          }
+      }
+    }
+
+    fun setIconRotationAlignment(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconRotationAlignment(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconRotationAlignment is null")
+        }
+      } else {
+          layer.iconRotationAlignment(IconRotationAlignment.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setIconSize(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconSize(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconSize is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconSize(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconSize is null")
+          }
+      }
+    }
+
+    fun setIconTextFit(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconTextFit(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconTextFit is null")
+        }
+      } else {
+          layer.iconTextFit(IconTextFit.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setIconTextFitPadding(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconTextFitPadding(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconTextFitPadding is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.iconTextFitPadding(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconTextFitPadding is null")
+          }
+      }
+    }
+
+    fun setIconImage(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue) {
+          val value = styleValue.getImageStringValue()
+          if (value != null) {
+            layer.iconImage(value)
+          } else {
+            e("RCTMGLSymbol", "Image for iconImage is null")
+          }
+        } else {
+          val expression = styleValue.getExpression()
+          if (expression != null) {
+            layer.iconImage(expression)
+          } else {
+            e("RCTMGLSymbol", "Expression for iconImage is null")
+          }
+        }
+      } else {
+        val value = styleValue.imageURI
+        if (value != null) {
+          layer.iconImage(value);
+        } else {
+          e("RCTMGLSymbol", "value for iconImage is null")
+        }
+      }
+    }
+
+    fun setIconRotate(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconRotate(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconRotate is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconRotate(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconRotate is null")
+          }
+      }
+    }
+
+    fun setIconPadding(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconPadding(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconPadding is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconPadding(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconPadding is null")
+          }
+      }
+    }
+
+    fun setIconKeepUpright(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconKeepUpright(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconKeepUpright is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.iconKeepUpright(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconKeepUpright is null")
+          }
+      }
+    }
+
+    fun setIconOffset(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconOffset(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconOffset is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.iconOffset(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconOffset is null")
+          }
+      }
+    }
+
+    fun setIconAnchor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconAnchor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconAnchor is null")
+        }
+      } else {
+          layer.iconAnchor(IconAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setIconPitchAlignment(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconPitchAlignment(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconPitchAlignment is null")
+        }
+      } else {
+          layer.iconPitchAlignment(IconPitchAlignment.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextPitchAlignment(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textPitchAlignment(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textPitchAlignment is null")
+        }
+      } else {
+          layer.textPitchAlignment(TextPitchAlignment.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextRotationAlignment(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textRotationAlignment(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textRotationAlignment is null")
+        }
+      } else {
+          layer.textRotationAlignment(TextRotationAlignment.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextField(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textField(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textField is null")
+        }
+      } else {
+          val value = styleValue.getString(VALUE_KEY)
+          if (value != null) {
+            layer.textField(value)
+          } else {
+            e("RCTMGLSymbol", "value for textField is null")
+          }
+      }
+    }
+
+    fun setTextFont(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textFont(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textFont is null")
+        }
+      } else {
+          val value = styleValue.getStringArray(VALUE_KEY)
+          if (value != null) {
+            layer.textFont(value)
+          } else {
+            e("RCTMGLSymbol", "value for textFont is null")
+          }
+      }
+    }
+
+    fun setTextSize(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textSize(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textSize is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textSize(value)
+          } else {
+            e("RCTMGLSymbol", "value for textSize is null")
+          }
+      }
+    }
+
+    fun setTextMaxWidth(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textMaxWidth(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textMaxWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textMaxWidth(value)
+          } else {
+            e("RCTMGLSymbol", "value for textMaxWidth is null")
+          }
+      }
+    }
+
+    fun setTextLineHeight(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textLineHeight(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textLineHeight is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textLineHeight(value)
+          } else {
+            e("RCTMGLSymbol", "value for textLineHeight is null")
+          }
+      }
+    }
+
+    fun setTextLetterSpacing(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textLetterSpacing(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textLetterSpacing is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textLetterSpacing(value)
+          } else {
+            e("RCTMGLSymbol", "value for textLetterSpacing is null")
+          }
+      }
+    }
+
+    fun setTextJustify(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textJustify(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textJustify is null")
+        }
+      } else {
+          layer.textJustify(TextJustify.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextRadialOffset(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textRadialOffset(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textRadialOffset is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textRadialOffset(value)
+          } else {
+            e("RCTMGLSymbol", "value for textRadialOffset is null")
+          }
+      }
+    }
+
+    fun setTextVariableAnchor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textVariableAnchor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textVariableAnchor is null")
+        }
+      } else {
+          val value = styleValue.getStringArray(VALUE_KEY)
+          if (value != null) {
+            layer.textVariableAnchor(value)
+          } else {
+            e("RCTMGLSymbol", "value for textVariableAnchor is null")
+          }
+      }
+    }
+
+    fun setTextAnchor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textAnchor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textAnchor is null")
+        }
+      } else {
+          layer.textAnchor(TextAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextMaxAngle(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textMaxAngle(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textMaxAngle is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textMaxAngle(value)
+          } else {
+            e("RCTMGLSymbol", "value for textMaxAngle is null")
+          }
+      }
+    }
+
+    fun setTextWritingMode(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textWritingMode(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textWritingMode is null")
+        }
+      } else {
+          val value = styleValue.getStringArray(VALUE_KEY)
+          if (value != null) {
+            layer.textWritingMode(value)
+          } else {
+            e("RCTMGLSymbol", "value for textWritingMode is null")
+          }
+      }
+    }
+
+    fun setTextRotate(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textRotate(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textRotate is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textRotate(value)
+          } else {
+            e("RCTMGLSymbol", "value for textRotate is null")
+          }
+      }
+    }
+
+    fun setTextPadding(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textPadding(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textPadding is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textPadding(value)
+          } else {
+            e("RCTMGLSymbol", "value for textPadding is null")
+          }
+      }
+    }
+
+    fun setTextKeepUpright(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textKeepUpright(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textKeepUpright is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.textKeepUpright(value)
+          } else {
+            e("RCTMGLSymbol", "value for textKeepUpright is null")
+          }
+      }
+    }
+
+    fun setTextTransform(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textTransform(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textTransform is null")
+        }
+      } else {
+          layer.textTransform(TextTransform.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextOffset(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textOffset(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textOffset is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.textOffset(value)
+          } else {
+            e("RCTMGLSymbol", "value for textOffset is null")
+          }
+      }
+    }
+
+    fun setTextAllowOverlap(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textAllowOverlap(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textAllowOverlap is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.textAllowOverlap(value)
+          } else {
+            e("RCTMGLSymbol", "value for textAllowOverlap is null")
+          }
+      }
+    }
+
+    fun setTextIgnorePlacement(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textIgnorePlacement(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textIgnorePlacement is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.textIgnorePlacement(value)
+          } else {
+            e("RCTMGLSymbol", "value for textIgnorePlacement is null")
+          }
+      }
+    }
+
+    fun setTextOptional(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textOptional(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textOptional is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.textOptional(value)
+          } else {
+            e("RCTMGLSymbol", "value for textOptional is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setIconOpacity(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconOpacity(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconOpacity(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconOpacity is null")
+          }
+      }
+    }
+
+
+    fun setIconOpacityTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconOpacityTransition(transition);
+      }
+    }
+
+    fun setIconColor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconColor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.iconColor(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconColor is null")
+          }
+      }
+    }
+
+
+    fun setIconColorTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconColorTransition(transition);
+      }
+    }
+
+    fun setIconHaloColor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconHaloColor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconHaloColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.iconHaloColor(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconHaloColor is null")
+          }
+      }
+    }
+
+
+    fun setIconHaloColorTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconHaloColorTransition(transition);
+      }
+    }
+
+    fun setIconHaloWidth(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconHaloWidth(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconHaloWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconHaloWidth(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconHaloWidth is null")
+          }
+      }
+    }
+
+
+    fun setIconHaloWidthTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconHaloWidthTransition(transition);
+      }
+    }
+
+    fun setIconHaloBlur(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconHaloBlur(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconHaloBlur is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.iconHaloBlur(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconHaloBlur is null")
+          }
+      }
+    }
+
+
+    fun setIconHaloBlurTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconHaloBlurTransition(transition);
+      }
+    }
+
+    fun setIconTranslate(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconTranslate(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.iconTranslate(value)
+          } else {
+            e("RCTMGLSymbol", "value for iconTranslate is null")
+          }
+      }
+    }
+
+
+    fun setIconTranslateTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.iconTranslateTransition(transition);
+      }
+    }
+
+    fun setIconTranslateAnchor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.iconTranslateAnchor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for iconTranslateAnchor is null")
+        }
+      } else {
+          layer.iconTranslateAnchor(IconTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setTextOpacity(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textOpacity(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textOpacity(value)
+          } else {
+            e("RCTMGLSymbol", "value for textOpacity is null")
+          }
+      }
+    }
+
+
+    fun setTextOpacityTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textOpacityTransition(transition);
+      }
+    }
+
+    fun setTextColor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textColor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.textColor(value)
+          } else {
+            e("RCTMGLSymbol", "value for textColor is null")
+          }
+      }
+    }
+
+
+    fun setTextColorTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textColorTransition(transition);
+      }
+    }
+
+    fun setTextHaloColor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textHaloColor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textHaloColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.textHaloColor(value)
+          } else {
+            e("RCTMGLSymbol", "value for textHaloColor is null")
+          }
+      }
+    }
+
+
+    fun setTextHaloColorTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textHaloColorTransition(transition);
+      }
+    }
+
+    fun setTextHaloWidth(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textHaloWidth(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textHaloWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textHaloWidth(value)
+          } else {
+            e("RCTMGLSymbol", "value for textHaloWidth is null")
+          }
+      }
+    }
+
+
+    fun setTextHaloWidthTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textHaloWidthTransition(transition);
+      }
+    }
+
+    fun setTextHaloBlur(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textHaloBlur(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textHaloBlur is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.textHaloBlur(value)
+          } else {
+            e("RCTMGLSymbol", "value for textHaloBlur is null")
+          }
+      }
+    }
+
+
+    fun setTextHaloBlurTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textHaloBlurTransition(transition);
+      }
+    }
+
+    fun setTextTranslate(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textTranslate(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.textTranslate(value)
+          } else {
+            e("RCTMGLSymbol", "value for textTranslate is null")
+          }
+      }
+    }
+
+
+    fun setTextTranslateTransition(layer: SymbolLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.textTranslateTransition(transition);
+      }
+    }
+
+    fun setTextTranslateAnchor(layer: SymbolLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.textTranslateAnchor(expression)
+        } else {
+          e("RCTMGLSymbol", "Expression for textTranslateAnchor is null")
+        }
+      } else {
+          layer.textTranslateAnchor(TextTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setCircleSortKey(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleSortKey(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleSortKey is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleSortKey(value)
+          } else {
+            e("RCTMGLCircle", "value for circleSortKey is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setCircleRadius(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleRadius(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleRadius is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleRadius(value)
+          } else {
+            e("RCTMGLCircle", "value for circleRadius is null")
+          }
+      }
+    }
+
+
+    fun setCircleRadiusTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleRadiusTransition(transition);
+      }
+    }
+
+    fun setCircleColor(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleColor(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.circleColor(value)
+          } else {
+            e("RCTMGLCircle", "value for circleColor is null")
+          }
+      }
+    }
+
+
+    fun setCircleColorTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleColorTransition(transition);
+      }
+    }
+
+    fun setCircleBlur(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleBlur(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleBlur is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleBlur(value)
+          } else {
+            e("RCTMGLCircle", "value for circleBlur is null")
+          }
+      }
+    }
+
+
+    fun setCircleBlurTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleBlurTransition(transition);
+      }
+    }
+
+    fun setCircleOpacity(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleOpacity(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleOpacity(value)
+          } else {
+            e("RCTMGLCircle", "value for circleOpacity is null")
+          }
+      }
+    }
+
+
+    fun setCircleOpacityTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleOpacityTransition(transition);
+      }
+    }
+
+    fun setCircleTranslate(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleTranslate(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.circleTranslate(value)
+          } else {
+            e("RCTMGLCircle", "value for circleTranslate is null")
+          }
+      }
+    }
+
+
+    fun setCircleTranslateTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleTranslateTransition(transition);
+      }
+    }
+
+    fun setCircleTranslateAnchor(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleTranslateAnchor(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleTranslateAnchor is null")
+        }
+      } else {
+          layer.circleTranslateAnchor(CircleTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setCirclePitchScale(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circlePitchScale(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circlePitchScale is null")
+        }
+      } else {
+          layer.circlePitchScale(CirclePitchScale.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setCirclePitchAlignment(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circlePitchAlignment(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circlePitchAlignment is null")
+        }
+      } else {
+          layer.circlePitchAlignment(CirclePitchAlignment.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setCircleStrokeWidth(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleStrokeWidth(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleStrokeWidth is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleStrokeWidth(value)
+          } else {
+            e("RCTMGLCircle", "value for circleStrokeWidth is null")
+          }
+      }
+    }
+
+
+    fun setCircleStrokeWidthTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleStrokeWidthTransition(transition);
+      }
+    }
+
+    fun setCircleStrokeColor(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleStrokeColor(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleStrokeColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.circleStrokeColor(value)
+          } else {
+            e("RCTMGLCircle", "value for circleStrokeColor is null")
+          }
+      }
+    }
+
+
+    fun setCircleStrokeColorTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleStrokeColorTransition(transition);
+      }
+    }
+
+    fun setCircleStrokeOpacity(layer: CircleLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.circleStrokeOpacity(expression)
+        } else {
+          e("RCTMGLCircle", "Expression for circleStrokeOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.circleStrokeOpacity(value)
+          } else {
+            e("RCTMGLCircle", "value for circleStrokeOpacity is null")
+          }
+      }
+    }
+
+
+    fun setCircleStrokeOpacityTransition(layer: CircleLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.circleStrokeOpacityTransition(transition);
+      }
+    }
+
+    fun setVisibility(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setHeatmapRadius(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.heatmapRadius(expression)
+        } else {
+          e("RCTMGLHeatmap", "Expression for heatmapRadius is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.heatmapRadius(value)
+          } else {
+            e("RCTMGLHeatmap", "value for heatmapRadius is null")
+          }
+      }
+    }
+
+
+    fun setHeatmapRadiusTransition(layer: HeatmapLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.heatmapRadiusTransition(transition);
+      }
+    }
+
+    fun setHeatmapWeight(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.heatmapWeight(expression)
+        } else {
+          e("RCTMGLHeatmap", "Expression for heatmapWeight is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.heatmapWeight(value)
+          } else {
+            e("RCTMGLHeatmap", "value for heatmapWeight is null")
+          }
+      }
+    }
+
+    fun setHeatmapIntensity(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.heatmapIntensity(expression)
+        } else {
+          e("RCTMGLHeatmap", "Expression for heatmapIntensity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.heatmapIntensity(value)
+          } else {
+            e("RCTMGLHeatmap", "value for heatmapIntensity is null")
+          }
+      }
+    }
+
+
+    fun setHeatmapIntensityTransition(layer: HeatmapLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.heatmapIntensityTransition(transition);
+      }
+    }
+
+    fun setHeatmapColor(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.heatmapColor(expression)
+        } else {
+          e("RCTMGLHeatmap", "Expression for heatmapColor is null")
+        }
+      } else {
+          layer.heatmapColor(styleValue.getIntExpression(VALUE_KEY))
+      }
+    }
+
+    fun setHeatmapOpacity(layer: HeatmapLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.heatmapOpacity(expression)
+        } else {
+          e("RCTMGLHeatmap", "Expression for heatmapOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.heatmapOpacity(value)
+          } else {
+            e("RCTMGLHeatmap", "value for heatmapOpacity is null")
+          }
+      }
+    }
+
+
+    fun setHeatmapOpacityTransition(layer: HeatmapLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.heatmapOpacityTransition(transition);
+      }
+    }
+
+    fun setVisibility(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setFillExtrusionOpacity(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionOpacity(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionOpacity(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionOpacity is null")
+          }
+      }
+    }
+
+
+    fun setFillExtrusionOpacityTransition(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillExtrusionOpacityTransition(transition);
+      }
+    }
+
+    fun setFillExtrusionColor(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionColor(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionColor(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionColor is null")
+          }
+      }
+    }
+
+
+    fun setFillExtrusionColorTransition(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillExtrusionColorTransition(transition);
+      }
+    }
+
+    fun setFillExtrusionTranslate(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionTranslate(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionTranslate is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionTranslate(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionTranslate is null")
+          }
+      }
+    }
+
+
+    fun setFillExtrusionTranslateTransition(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillExtrusionTranslateTransition(transition);
+      }
+    }
+
+    fun setFillExtrusionTranslateAnchor(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionTranslateAnchor(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionTranslateAnchor is null")
+        }
+      } else {
+          layer.fillExtrusionTranslateAnchor(FillExtrusionTranslateAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setFillExtrusionPattern(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue) {
+          val value = styleValue.getImageStringValue()
+          if (value != null) {
+            layer.fillExtrusionPattern(value)
+          } else {
+            e("RCTMGLFillExtrusion", "Image for fillExtrusionPattern is null")
+          }
+        } else {
+          val expression = styleValue.getExpression()
+          if (expression != null) {
+            layer.fillExtrusionPattern(expression)
+          } else {
+            e("RCTMGLFillExtrusion", "Expression for fillExtrusionPattern is null")
+          }
+        }
+      } else {
+        val value = styleValue.imageURI
+        if (value != null) {
+          layer.fillExtrusionPattern(value);
+        } else {
+          e("RCTMGLFillExtrusion", "value for fillExtrusionPattern is null")
+        }
+      }
+    }
+
+    fun setFillExtrusionHeight(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionHeight(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionHeight is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionHeight(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionHeight is null")
+          }
+      }
+    }
+
+
+    fun setFillExtrusionHeightTransition(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillExtrusionHeightTransition(transition);
+      }
+    }
+
+    fun setFillExtrusionBase(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionBase(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionBase is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionBase(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionBase is null")
+          }
+      }
+    }
+
+
+    fun setFillExtrusionBaseTransition(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.fillExtrusionBaseTransition(transition);
+      }
+    }
+
+    fun setFillExtrusionVerticalGradient(layer: FillExtrusionLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.fillExtrusionVerticalGradient(expression)
+        } else {
+          e("RCTMGLFillExtrusion", "Expression for fillExtrusionVerticalGradient is null")
+        }
+      } else {
+          val value = styleValue.getBoolean(VALUE_KEY)
+          if (value != null) {
+            layer.fillExtrusionVerticalGradient(value)
+          } else {
+            e("RCTMGLFillExtrusion", "value for fillExtrusionVerticalGradient is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setRasterOpacity(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterOpacity(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterOpacity(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterOpacity is null")
+          }
+      }
+    }
+
+
+    fun setRasterOpacityTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterOpacityTransition(transition);
+      }
+    }
+
+    fun setRasterHueRotate(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterHueRotate(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterHueRotate is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterHueRotate(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterHueRotate is null")
+          }
+      }
+    }
+
+
+    fun setRasterHueRotateTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterHueRotateTransition(transition);
+      }
+    }
+
+    fun setRasterBrightnessMin(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterBrightnessMin(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterBrightnessMin is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterBrightnessMin(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterBrightnessMin is null")
+          }
+      }
+    }
+
+
+    fun setRasterBrightnessMinTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterBrightnessMinTransition(transition);
+      }
+    }
+
+    fun setRasterBrightnessMax(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterBrightnessMax(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterBrightnessMax is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterBrightnessMax(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterBrightnessMax is null")
+          }
+      }
+    }
+
+
+    fun setRasterBrightnessMaxTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterBrightnessMaxTransition(transition);
+      }
+    }
+
+    fun setRasterSaturation(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterSaturation(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterSaturation is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterSaturation(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterSaturation is null")
+          }
+      }
+    }
+
+
+    fun setRasterSaturationTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterSaturationTransition(transition);
+      }
+    }
+
+    fun setRasterContrast(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterContrast(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterContrast is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterContrast(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterContrast is null")
+          }
+      }
+    }
+
+
+    fun setRasterContrastTransition(layer: RasterLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterContrastTransition(transition);
+      }
+    }
+
+    fun setRasterResampling(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterResampling(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterResampling is null")
+        }
+      } else {
+          layer.rasterResampling(RasterResampling.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setRasterFadeDuration(layer: RasterLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterFadeDuration(expression)
+        } else {
+          e("RCTMGLRaster", "Expression for rasterFadeDuration is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterFadeDuration(value)
+          } else {
+            e("RCTMGLRaster", "value for rasterFadeDuration is null")
+          }
+      }
+    }
+
+    fun setVisibility(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setHillshadeIlluminationDirection(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeIlluminationDirection(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeIlluminationDirection is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.hillshadeIlluminationDirection(value)
+          } else {
+            e("RCTMGLHillshade", "value for hillshadeIlluminationDirection is null")
+          }
+      }
+    }
+
+    fun setHillshadeIlluminationAnchor(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeIlluminationAnchor(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeIlluminationAnchor is null")
+        }
+      } else {
+          layer.hillshadeIlluminationAnchor(HillshadeIlluminationAnchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setHillshadeExaggeration(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeExaggeration(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeExaggeration is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.hillshadeExaggeration(value)
+          } else {
+            e("RCTMGLHillshade", "value for hillshadeExaggeration is null")
+          }
+      }
+    }
+
+
+    fun setHillshadeExaggerationTransition(layer: HillshadeLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.hillshadeExaggerationTransition(transition);
+      }
+    }
+
+    fun setHillshadeShadowColor(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeShadowColor(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeShadowColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.hillshadeShadowColor(value)
+          } else {
+            e("RCTMGLHillshade", "value for hillshadeShadowColor is null")
+          }
+      }
+    }
+
+
+    fun setHillshadeShadowColorTransition(layer: HillshadeLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.hillshadeShadowColorTransition(transition);
+      }
+    }
+
+    fun setHillshadeHighlightColor(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeHighlightColor(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeHighlightColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.hillshadeHighlightColor(value)
+          } else {
+            e("RCTMGLHillshade", "value for hillshadeHighlightColor is null")
+          }
+      }
+    }
+
+
+    fun setHillshadeHighlightColorTransition(layer: HillshadeLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.hillshadeHighlightColorTransition(transition);
+      }
+    }
+
+    fun setHillshadeAccentColor(layer: HillshadeLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeAccentColor(expression)
+        } else {
+          e("RCTMGLHillshade", "Expression for hillshadeAccentColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.hillshadeAccentColor(value)
+          } else {
+            e("RCTMGLHillshade", "value for hillshadeAccentColor is null")
+          }
+      }
+    }
+
+
+    fun setHillshadeAccentColorTransition(layer: HillshadeLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.hillshadeAccentColorTransition(transition);
+      }
+    }
+
+    fun setVisibility(layer: BackgroundLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setBackgroundColor(layer: BackgroundLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.backgroundColor(expression)
+        } else {
+          e("RCTMGLBackground", "Expression for backgroundColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.backgroundColor(value)
+          } else {
+            e("RCTMGLBackground", "value for backgroundColor is null")
+          }
+      }
+    }
+
+
+    fun setBackgroundColorTransition(layer: BackgroundLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.backgroundColorTransition(transition);
+      }
+    }
+
+    fun setBackgroundPattern(layer: BackgroundLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        if (styleValue.isImageStringValue) {
+          val value = styleValue.getImageStringValue()
+          if (value != null) {
+            layer.backgroundPattern(value)
+          } else {
+            e("RCTMGLBackground", "Image for backgroundPattern is null")
+          }
+        } else {
+          val expression = styleValue.getExpression()
+          if (expression != null) {
+            layer.backgroundPattern(expression)
+          } else {
+            e("RCTMGLBackground", "Expression for backgroundPattern is null")
+          }
+        }
+      } else {
+        val value = styleValue.imageURI
+        if (value != null) {
+          layer.backgroundPattern(value);
+        } else {
+          e("RCTMGLBackground", "value for backgroundPattern is null")
+        }
+      }
+    }
+
+    fun setBackgroundOpacity(layer: BackgroundLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.backgroundOpacity(expression)
+        } else {
+          e("RCTMGLBackground", "Expression for backgroundOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.backgroundOpacity(value)
+          } else {
+            e("RCTMGLBackground", "value for backgroundOpacity is null")
+          }
+      }
+    }
+
+
+    fun setBackgroundOpacityTransition(layer: BackgroundLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.backgroundOpacityTransition(transition);
+      }
+    }
+
+    fun setVisibility(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setSkyType(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyType(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyType is null")
+        }
+      } else {
+          layer.skyType(SkyType.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setSkyAtmosphereSun(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyAtmosphereSun(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyAtmosphereSun is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.skyAtmosphereSun(value)
+          } else {
+            e("RCTMGLSky", "value for skyAtmosphereSun is null")
+          }
+      }
+    }
+
+    fun setSkyAtmosphereSunIntensity(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyAtmosphereSunIntensity(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyAtmosphereSunIntensity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.skyAtmosphereSunIntensity(value)
+          } else {
+            e("RCTMGLSky", "value for skyAtmosphereSunIntensity is null")
+          }
+      }
+    }
+
+    fun setSkyGradientCenter(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyGradientCenter(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyGradientCenter is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.skyGradientCenter(value)
+          } else {
+            e("RCTMGLSky", "value for skyGradientCenter is null")
+          }
+      }
+    }
+
+    fun setSkyGradientRadius(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyGradientRadius(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyGradientRadius is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.skyGradientRadius(value)
+          } else {
+            e("RCTMGLSky", "value for skyGradientRadius is null")
+          }
+      }
+    }
+
+    fun setSkyGradient(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyGradient(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyGradient is null")
+        }
+      } else {
+          layer.skyGradient(styleValue.getIntExpression(VALUE_KEY))
+      }
+    }
+
+    fun setSkyAtmosphereHaloColor(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyAtmosphereHaloColor(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyAtmosphereHaloColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.skyAtmosphereHaloColor(value)
+          } else {
+            e("RCTMGLSky", "value for skyAtmosphereHaloColor is null")
+          }
+      }
+    }
+
+    fun setSkyAtmosphereColor(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyAtmosphereColor(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyAtmosphereColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.skyAtmosphereColor(value)
+          } else {
+            e("RCTMGLSky", "value for skyAtmosphereColor is null")
+          }
+      }
+    }
+
+    fun setSkyOpacity(layer: SkyLayer, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.skyOpacity(expression)
+        } else {
+          e("RCTMGLSky", "Expression for skyOpacity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.skyOpacity(value)
+          } else {
+            e("RCTMGLSky", "value for skyOpacity is null")
+          }
+      }
+    }
+
+
+    fun setSkyOpacityTransition(layer: SkyLayer, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.skyOpacityTransition(transition);
+      }
+    }
+
+    fun setAnchor(layer: Light, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.anchor(expression)
+        } else {
+          e("RCTMGLLight", "Expression for anchor is null")
+        }
+      } else {
+          layer.anchor(Anchor.valueOf(styleValue.getEnumName()))
+      }
+    }
+
+    fun setPosition(layer: Light, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.position(expression)
+        } else {
+          e("RCTMGLLight", "Expression for position is null")
+        }
+      } else {
+          layer.position(styleValue.getLightPosition())
+      }
+    }
+
+
+    fun setPositionTransition(layer: Light, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.positionTransition(transition);
+      }
+    }
+
+    fun setColor(layer: Light, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.color(expression)
+        } else {
+          e("RCTMGLLight", "Expression for color is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.color(value)
+          } else {
+            e("RCTMGLLight", "value for color is null")
+          }
+      }
+    }
+
+
+    fun setColorTransition(layer: Light, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.colorTransition(transition);
+      }
+    }
+
+    fun setIntensity(layer: Light, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.intensity(expression)
+        } else {
+          e("RCTMGLLight", "Expression for intensity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.intensity(value)
+          } else {
+            e("RCTMGLLight", "value for intensity is null")
+          }
+      }
+    }
+
+
+    fun setIntensityTransition(layer: Light, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.intensityTransition(transition);
+      }
+    }
+
+    fun setRange(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.range(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for range is null")
+        }
+      } else {
+          val value = styleValue.getFloatArray(VALUE_KEY)
+          if (value != null) {
+            layer.range(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for range is null")
+          }
+      }
+    }
+
+
+    fun setRangeTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rangeTransition(transition);
+      }
+    }
+
+    fun setColor(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.color(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for color is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.color(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for color is null")
+          }
+      }
+    }
+
+
+    fun setColorTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.colorTransition(transition);
+      }
+    }
+
+    fun setHighColor(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.highColor(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for highColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.highColor(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for highColor is null")
+          }
+      }
+    }
+
+
+    fun setHighColorTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.highColorTransition(transition);
+      }
+    }
+
+    fun setSpaceColor(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.spaceColor(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for spaceColor is null")
+        }
+      } else {
+          val value = styleValue.getInt(VALUE_KEY)
+          if (value != null) {
+            layer.spaceColor(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for spaceColor is null")
+          }
+      }
+    }
+
+
+    fun setSpaceColorTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.spaceColorTransition(transition);
+      }
+    }
+
+    fun setHorizonBlend(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.horizonBlend(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for horizonBlend is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.horizonBlend(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for horizonBlend is null")
+          }
+      }
+    }
+
+
+    fun setHorizonBlendTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.horizonBlendTransition(transition);
+      }
+    }
+
+    fun setStarIntensity(layer: Atmosphere, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.starIntensity(expression)
+        } else {
+          e("RCTMGLAtmosphere", "Expression for starIntensity is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.starIntensity(value)
+          } else {
+            e("RCTMGLAtmosphere", "value for starIntensity is null")
+          }
+      }
+    }
+
+
+    fun setStarIntensityTransition(layer: Atmosphere, styleValue: RCTMGLStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.starIntensityTransition(transition);
+      }
+    }
+
+    fun setExaggeration(layer: Terrain, styleValue: RCTMGLStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.exaggeration(expression)
+        } else {
+          e("RCTMGLTerrain", "Expression for exaggeration is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.exaggeration(value)
+          } else {
+            e("RCTMGLTerrain", "value for exaggeration is null")
+          }
+      }
+    }
+
+}