@rnmapbox/maps 10.1.0-rc.6 → 10.1.0

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt

@@ -17,7 +17,6 @@ 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.generated.ModelLayer
 // 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
@@ -27,7 +26,6 @@ import com.rnmapbox.rnmbx.utils.DownloadMapImageTask.OnAllImagesLoaded
 import com.rnmapbox.rnmbx.utils.Logger.e
 
 import com.rnmapbox.rnmbx.v11compat.light.*;
-import com.rnmapbox.rnmbx.v11compat.stylefactory.*;
 
 import java.util.List;
 
@@ -80,10 +78,6 @@ object RNMBXStyleFactory {
                       }
                   }
               })
-            "fillEmissiveStrength" ->
-              setFillEmissiveStrength(layer, styleValue)
-              "fillEmissiveStrengthTransition" ->
-              setFillEmissiveStrengthTransition(layer, styleValue)
         }
       }
     }
@@ -156,10 +150,6 @@ object RNMBXStyleFactory {
               setLineGradient(layer, styleValue)
             "lineTrimOffset" ->
               setLineTrimOffset(layer, styleValue)
-            "lineEmissiveStrength" ->
-              setLineEmissiveStrength(layer, styleValue)
-              "lineEmissiveStrengthTransition" ->
-              setLineEmissiveStrengthTransition(layer, styleValue)
         }
       }
     }
@@ -318,28 +308,6 @@ object RNMBXStyleFactory {
               setTextTranslateTransition(layer, styleValue)
             "textTranslateAnchor" ->
               setTextTranslateAnchor(layer, styleValue)
-            "symbolZElevate" ->
-              setSymbolZElevate(layer, styleValue)
-            "iconEmissiveStrength" ->
-              setIconEmissiveStrength(layer, styleValue)
-              "iconEmissiveStrengthTransition" ->
-              setIconEmissiveStrengthTransition(layer, styleValue)
-            "textEmissiveStrength" ->
-              setTextEmissiveStrength(layer, styleValue)
-              "textEmissiveStrengthTransition" ->
-              setTextEmissiveStrengthTransition(layer, styleValue)
-            "iconImageCrossFade" ->
-              style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
-                  override fun onAllImagesLoaded() {
-                      try {
-                          setIconImageCrossFade(layer, styleValue)
-                      } catch (exception: RuntimeException) {
-                          e("RNMBXSymbol",String.format("Exception failed during setIconImageCrossFade: %s", exception.message))
-                      }
-                  }
-              })
-              "iconImageCrossFadeTransition" ->
-              setIconImageCrossFadeTransition(layer, styleValue)
         }
       }
     }
@@ -396,10 +364,6 @@ object RNMBXStyleFactory {
               setCircleStrokeOpacity(layer, styleValue)
               "circleStrokeOpacityTransition" ->
               setCircleStrokeOpacityTransition(layer, styleValue)
-            "circleEmissiveStrength" ->
-              setCircleEmissiveStrength(layer, styleValue)
-              "circleEmissiveStrengthTransition" ->
-              setCircleEmissiveStrengthTransition(layer, styleValue)
         }
       }
     }
@@ -482,46 +446,6 @@ object RNMBXStyleFactory {
               setFillExtrusionBaseTransition(layer, styleValue)
             "fillExtrusionVerticalGradient" ->
               setFillExtrusionVerticalGradient(layer, styleValue)
-            "fillExtrusionRoundedRoof" ->
-              setFillExtrusionRoundedRoof(layer, styleValue)
-            "fillExtrusionAmbientOcclusionWallRadius" ->
-              setFillExtrusionAmbientOcclusionWallRadius(layer, styleValue)
-              "fillExtrusionAmbientOcclusionWallRadiusTransition" ->
-              setFillExtrusionAmbientOcclusionWallRadiusTransition(layer, styleValue)
-            "fillExtrusionAmbientOcclusionGroundRadius" ->
-              setFillExtrusionAmbientOcclusionGroundRadius(layer, styleValue)
-              "fillExtrusionAmbientOcclusionGroundRadiusTransition" ->
-              setFillExtrusionAmbientOcclusionGroundRadiusTransition(layer, styleValue)
-            "fillExtrusionAmbientOcclusionGroundAttenuation" ->
-              setFillExtrusionAmbientOcclusionGroundAttenuation(layer, styleValue)
-              "fillExtrusionAmbientOcclusionGroundAttenuationTransition" ->
-              setFillExtrusionAmbientOcclusionGroundAttenuationTransition(layer, styleValue)
-            "fillExtrusionFloodLightColor" ->
-              setFillExtrusionFloodLightColor(layer, styleValue)
-              "fillExtrusionFloodLightColorTransition" ->
-              setFillExtrusionFloodLightColorTransition(layer, styleValue)
-            "fillExtrusionFloodLightIntensity" ->
-              setFillExtrusionFloodLightIntensity(layer, styleValue)
-              "fillExtrusionFloodLightIntensityTransition" ->
-              setFillExtrusionFloodLightIntensityTransition(layer, styleValue)
-            "fillExtrusionFloodLightWallRadius" ->
-              setFillExtrusionFloodLightWallRadius(layer, styleValue)
-              "fillExtrusionFloodLightWallRadiusTransition" ->
-              setFillExtrusionFloodLightWallRadiusTransition(layer, styleValue)
-            "fillExtrusionFloodLightGroundRadius" ->
-              setFillExtrusionFloodLightGroundRadius(layer, styleValue)
-              "fillExtrusionFloodLightGroundRadiusTransition" ->
-              setFillExtrusionFloodLightGroundRadiusTransition(layer, styleValue)
-            "fillExtrusionFloodLightGroundAttenuation" ->
-              setFillExtrusionFloodLightGroundAttenuation(layer, styleValue)
-              "fillExtrusionFloodLightGroundAttenuationTransition" ->
-              setFillExtrusionFloodLightGroundAttenuationTransition(layer, styleValue)
-            "fillExtrusionVerticalScale" ->
-              setFillExtrusionVerticalScale(layer, styleValue)
-              "fillExtrusionVerticalScaleTransition" ->
-              setFillExtrusionVerticalScaleTransition(layer, styleValue)
-            "fillExtrusionCutoffFadeRange" ->
-              setFillExtrusionCutoffFadeRange(layer, styleValue)
         }
       }
     }
@@ -566,16 +490,6 @@ object RNMBXStyleFactory {
               setRasterResampling(layer, styleValue)
             "rasterFadeDuration" ->
               setRasterFadeDuration(layer, styleValue)
-            "rasterColor" ->
-              setRasterColor(layer, styleValue)
-            "rasterColorMix" ->
-              setRasterColorMix(layer, styleValue)
-              "rasterColorMixTransition" ->
-              setRasterColorMixTransition(layer, styleValue)
-            "rasterColorRange" ->
-              setRasterColorRange(layer, styleValue)
-              "rasterColorRangeTransition" ->
-              setRasterColorRangeTransition(layer, styleValue)
         }
       }
     }
@@ -615,72 +529,6 @@ object RNMBXStyleFactory {
         }
       }
     }
-    fun setModelLayerStyle(layer: ModelLayer, style: RNMBXStyle ) {
-      val styleKeys = style.allStyleKeys
-
-      if (styleKeys.isEmpty()) {
-        return
-      }
-
-      for (styleKey in styleKeys) {
-        val styleValue = style.getStyleValueForKey(styleKey)
-
-        when (styleKey) {
-            "visibility" ->
-              setVisibility(layer, styleValue)
-            "modelId" ->
-              setModelId(layer, styleValue)
-            "modelOpacity" ->
-              setModelOpacity(layer, styleValue)
-              "modelOpacityTransition" ->
-              setModelOpacityTransition(layer, styleValue)
-            "modelRotation" ->
-              setModelRotation(layer, styleValue)
-              "modelRotationTransition" ->
-              setModelRotationTransition(layer, styleValue)
-            "modelScale" ->
-              setModelScale(layer, styleValue)
-              "modelScaleTransition" ->
-              setModelScaleTransition(layer, styleValue)
-            "modelTranslation" ->
-              setModelTranslation(layer, styleValue)
-              "modelTranslationTransition" ->
-              setModelTranslationTransition(layer, styleValue)
-            "modelColor" ->
-              setModelColor(layer, styleValue)
-              "modelColorTransition" ->
-              setModelColorTransition(layer, styleValue)
-            "modelColorMixIntensity" ->
-              setModelColorMixIntensity(layer, styleValue)
-              "modelColorMixIntensityTransition" ->
-              setModelColorMixIntensityTransition(layer, styleValue)
-            "modelType" ->
-              setModelType(layer, styleValue)
-            "modelCastShadows" ->
-              setModelCastShadows(layer, styleValue)
-            "modelReceiveShadows" ->
-              setModelReceiveShadows(layer, styleValue)
-            "modelAmbientOcclusionIntensity" ->
-              setModelAmbientOcclusionIntensity(layer, styleValue)
-              "modelAmbientOcclusionIntensityTransition" ->
-              setModelAmbientOcclusionIntensityTransition(layer, styleValue)
-            "modelEmissiveStrength" ->
-              setModelEmissiveStrength(layer, styleValue)
-              "modelEmissiveStrengthTransition" ->
-              setModelEmissiveStrengthTransition(layer, styleValue)
-            "modelRoughness" ->
-              setModelRoughness(layer, styleValue)
-              "modelRoughnessTransition" ->
-              setModelRoughnessTransition(layer, styleValue)
-            "modelHeightBasedEmissiveStrengthMultiplier" ->
-              setModelHeightBasedEmissiveStrengthMultiplier(layer, styleValue)
-              "modelHeightBasedEmissiveStrengthMultiplierTransition" ->
-              setModelHeightBasedEmissiveStrengthMultiplierTransition(layer, styleValue)
-            "modelCutoffFadeRange" ->
-              setModelCutoffFadeRange(layer, styleValue)
-        }
-      }
-    }
     fun setBackgroundLayerStyle(layer: BackgroundLayer, style: RNMBXStyle ) {
       val styleKeys = style.allStyleKeys
 
@@ -712,10 +560,6 @@ object RNMBXStyleFactory {
               setBackgroundOpacity(layer, styleValue)
               "backgroundOpacityTransition" ->
               setBackgroundOpacityTransition(layer, styleValue)
-            "backgroundEmissiveStrength" ->
-              setBackgroundEmissiveStrength(layer, styleValue)
-              "backgroundEmissiveStrengthTransition" ->
-              setBackgroundEmissiveStrengthTransition(layer, styleValue)
         }
       }
     }
@@ -818,10 +662,6 @@ object RNMBXStyleFactory {
               setStarIntensity(layer, styleValue)
               "starIntensityTransition" ->
               setStarIntensityTransition(layer, styleValue)
-            "verticalRange" ->
-              setVerticalRange(layer, styleValue)
-              "verticalRangeTransition" ->
-              setVerticalRangeTransition(layer, styleValue)
         }
       }
     }
@@ -1026,32 +866,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setFillEmissiveStrength(layer: FillLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.fillEmissiveStrength(expression)
-        } else {
-          e("RNMBXFill", "Expression for fillEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.fillEmissiveStrength(value)
-          } else {
-            e("RNMBXFill", "value for fillEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setFillEmissiveStrengthTransition(layer: FillLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.fillEmissiveStrengthTransition(transition);
-      }
-    }
-
     fun setLineCap(layer: LineLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
@@ -1407,32 +1221,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setLineEmissiveStrength(layer: LineLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.lineEmissiveStrength(expression)
-        } else {
-          e("RNMBXLine", "Expression for lineEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.lineEmissiveStrength(value)
-          } else {
-            e("RNMBXLine", "value for lineEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setLineEmissiveStrengthTransition(layer: LineLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.lineEmissiveStrengthTransition(transition);
-      }
-    }
-
     fun setSymbolPlacement(layer: SymbolLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
@@ -2467,102 +2255,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setSymbolZElevate(layer: SymbolLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.symbolZElevate(expression)
-        } else {
-          e("RNMBXSymbol", "Expression for symbolZElevate is null")
-        }
-      } else {
-          val value = styleValue.getBoolean(VALUE_KEY)
-          if (value != null) {
-            layer.symbolZElevate(value)
-          } else {
-            e("RNMBXSymbol", "value for symbolZElevate is null")
-          }
-      }
-    }
-
-    fun setIconEmissiveStrength(layer: SymbolLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.iconEmissiveStrength(expression)
-        } else {
-          e("RNMBXSymbol", "Expression for iconEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.iconEmissiveStrength(value)
-          } else {
-            e("RNMBXSymbol", "value for iconEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setIconEmissiveStrengthTransition(layer: SymbolLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.iconEmissiveStrengthTransition(transition);
-      }
-    }
-
-    fun setTextEmissiveStrength(layer: SymbolLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.textEmissiveStrength(expression)
-        } else {
-          e("RNMBXSymbol", "Expression for textEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.textEmissiveStrength(value)
-          } else {
-            e("RNMBXSymbol", "value for textEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setTextEmissiveStrengthTransition(layer: SymbolLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.textEmissiveStrengthTransition(transition);
-      }
-    }
-
-    fun setIconImageCrossFade(layer: SymbolLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.iconImageCrossFade(expression)
-        } else {
-          e("RNMBXSymbol", "Expression for iconImageCrossFade is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.iconImageCrossFade(value)
-          } else {
-            e("RNMBXSymbol", "value for iconImageCrossFade is null")
-          }
-      }
-    }
-
-
-    fun setIconImageCrossFadeTransition(layer: SymbolLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.iconImageCrossFadeTransition(transition);
-      }
-    }
-
     fun setCircleSortKey(layer: CircleLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
@@ -2832,32 +2524,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setCircleEmissiveStrength(layer: CircleLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.circleEmissiveStrength(expression)
-        } else {
-          e("RNMBXCircle", "Expression for circleEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.circleEmissiveStrength(value)
-          } else {
-            e("RNMBXCircle", "value for circleEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setCircleEmissiveStrengthTransition(layer: CircleLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.circleEmissiveStrengthTransition(transition);
-      }
-    }
-
     fun setVisibility(layer: HeatmapLayer, styleValue: RNMBXStyleValue ) {
         layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }
@@ -3163,1022 +2829,333 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setFillExtrusionRoundedRoof(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.fillExtrusionRoundedRoof(expression)
-        } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionRoundedRoof is null")
-        }
-      } else {
-          val value = styleValue.getBoolean(VALUE_KEY)
-          if (value != null) {
-            layer.fillExtrusionRoundedRoof(value)
-          } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionRoundedRoof is null")
-          }
-      }
+    fun setVisibility(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }
 
-    fun setFillExtrusionAmbientOcclusionWallRadius(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterOpacity(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionAmbientOcclusionWallRadius(expression)
+          layer.rasterOpacity(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionWallRadius is null")
+          e("RNMBXRaster", "Expression for rasterOpacity is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionAmbientOcclusionWallRadius(value)
+            layer.rasterOpacity(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionWallRadius is null")
+            e("RNMBXRaster", "value for rasterOpacity is null")
           }
       }
     }
 
 
-    fun setFillExtrusionAmbientOcclusionWallRadiusTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterOpacityTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionAmbientOcclusionWallRadiusTransition(transition);
+        layer.rasterOpacityTransition(transition);
       }
     }
 
-    fun setFillExtrusionAmbientOcclusionGroundRadius(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterHueRotate(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionAmbientOcclusionGroundRadius(expression)
+          layer.rasterHueRotate(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundRadius is null")
+          e("RNMBXRaster", "Expression for rasterHueRotate is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionAmbientOcclusionGroundRadius(value)
+            layer.rasterHueRotate(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundRadius is null")
+            e("RNMBXRaster", "value for rasterHueRotate is null")
           }
       }
     }
 
 
-    fun setFillExtrusionAmbientOcclusionGroundRadiusTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterHueRotateTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionAmbientOcclusionGroundRadiusTransition(transition);
+        layer.rasterHueRotateTransition(transition);
       }
     }
 
-    fun setFillExtrusionAmbientOcclusionGroundAttenuation(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterBrightnessMin(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionAmbientOcclusionGroundAttenuation(expression)
+          layer.rasterBrightnessMin(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundAttenuation is null")
+          e("RNMBXRaster", "Expression for rasterBrightnessMin is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionAmbientOcclusionGroundAttenuation(value)
+            layer.rasterBrightnessMin(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundAttenuation is null")
+            e("RNMBXRaster", "value for rasterBrightnessMin is null")
           }
       }
     }
 
 
-    fun setFillExtrusionAmbientOcclusionGroundAttenuationTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterBrightnessMinTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionAmbientOcclusionGroundAttenuationTransition(transition);
+        layer.rasterBrightnessMinTransition(transition);
       }
     }
 
-    fun setFillExtrusionFloodLightColor(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterBrightnessMax(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionFloodLightColor(expression)
+          layer.rasterBrightnessMax(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightColor is null")
+          e("RNMBXRaster", "Expression for rasterBrightnessMax is null")
         }
       } else {
-          val value = styleValue.getInt(VALUE_KEY)
+          val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionFloodLightColor(value)
+            layer.rasterBrightnessMax(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightColor is null")
+            e("RNMBXRaster", "value for rasterBrightnessMax is null")
           }
       }
     }
 
 
-    fun setFillExtrusionFloodLightColorTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterBrightnessMaxTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionFloodLightColorTransition(transition);
+        layer.rasterBrightnessMaxTransition(transition);
       }
     }
 
-    fun setFillExtrusionFloodLightIntensity(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterSaturation(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionFloodLightIntensity(expression)
+          layer.rasterSaturation(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightIntensity is null")
+          e("RNMBXRaster", "Expression for rasterSaturation is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionFloodLightIntensity(value)
+            layer.rasterSaturation(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightIntensity is null")
+            e("RNMBXRaster", "value for rasterSaturation is null")
           }
       }
     }
 
 
-    fun setFillExtrusionFloodLightIntensityTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterSaturationTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionFloodLightIntensityTransition(transition);
+        layer.rasterSaturationTransition(transition);
       }
     }
 
-    fun setFillExtrusionFloodLightWallRadius(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterContrast(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionFloodLightWallRadius(expression)
+          layer.rasterContrast(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightWallRadius is null")
+          e("RNMBXRaster", "Expression for rasterContrast is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionFloodLightWallRadius(value)
+            layer.rasterContrast(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightWallRadius is null")
+            e("RNMBXRaster", "value for rasterContrast is null")
           }
       }
     }
 
 
-    fun setFillExtrusionFloodLightWallRadiusTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
+    fun setRasterContrastTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.fillExtrusionFloodLightWallRadiusTransition(transition);
+        layer.rasterContrastTransition(transition);
       }
     }
 
-    fun setFillExtrusionFloodLightGroundRadius(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterResampling(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionFloodLightGroundRadius(expression)
+          layer.rasterResampling(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundRadius is null")
+          e("RNMBXRaster", "Expression for rasterResampling is null")
         }
       } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.fillExtrusionFloodLightGroundRadius(value)
-          } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundRadius is null")
-          }
-      }
-    }
-
-
-    fun setFillExtrusionFloodLightGroundRadiusTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.fillExtrusionFloodLightGroundRadiusTransition(transition);
+          layer.rasterResampling(RasterResampling.valueOf(styleValue.getEnumName()))
       }
     }
 
-    fun setFillExtrusionFloodLightGroundAttenuation(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setRasterFadeDuration(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionFloodLightGroundAttenuation(expression)
+          layer.rasterFadeDuration(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundAttenuation is null")
+          e("RNMBXRaster", "Expression for rasterFadeDuration is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionFloodLightGroundAttenuation(value)
+            layer.rasterFadeDuration(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundAttenuation is null")
+            e("RNMBXRaster", "value for rasterFadeDuration is null")
           }
       }
     }
 
-
-    fun setFillExtrusionFloodLightGroundAttenuationTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.fillExtrusionFloodLightGroundAttenuationTransition(transition);
-      }
+    fun setVisibility(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }
 
-    fun setFillExtrusionVerticalScale(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setHillshadeIlluminationDirection(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionVerticalScale(expression)
+          layer.hillshadeIlluminationDirection(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionVerticalScale is null")
+          e("RNMBXHillshade", "Expression for hillshadeIlluminationDirection is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionVerticalScale(value)
+            layer.hillshadeIlluminationDirection(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionVerticalScale is null")
+            e("RNMBXHillshade", "value for hillshadeIlluminationDirection is null")
           }
       }
     }
 
-
-    fun setFillExtrusionVerticalScaleTransition(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.fillExtrusionVerticalScaleTransition(transition);
+    fun setHillshadeIlluminationAnchor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.hillshadeIlluminationAnchor(expression)
+        } else {
+          e("RNMBXHillshade", "Expression for hillshadeIlluminationAnchor is null")
+        }
+      } else {
+          layer.hillshadeIlluminationAnchor(HillshadeIlluminationAnchor.valueOf(styleValue.getEnumName()))
       }
     }
 
-    fun setFillExtrusionCutoffFadeRange(layer: FillExtrusionLayer, styleValue: RNMBXStyleValue ) {
+    fun setHillshadeExaggeration(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.fillExtrusionCutoffFadeRange(expression)
+          layer.hillshadeExaggeration(expression)
         } else {
-          e("RNMBXFillExtrusion", "Expression for fillExtrusionCutoffFadeRange is null")
+          e("RNMBXHillshade", "Expression for hillshadeExaggeration is null")
         }
       } else {
           val value = styleValue.getDouble(VALUE_KEY)
           if (value != null) {
-            layer.fillExtrusionCutoffFadeRange(value)
+            layer.hillshadeExaggeration(value)
           } else {
-            e("RNMBXFillExtrusion", "value for fillExtrusionCutoffFadeRange is null")
-          }
-      }
-    }
-
-    fun setVisibility(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
-    }
-
-    fun setRasterOpacity(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterOpacity(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterOpacity is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterOpacity(value)
-          } else {
-            e("RNMBXRaster", "value for rasterOpacity is null")
-          }
-      }
-    }
-
-
-    fun setRasterOpacityTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterOpacityTransition(transition);
-      }
-    }
-
-    fun setRasterHueRotate(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterHueRotate(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterHueRotate is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterHueRotate(value)
-          } else {
-            e("RNMBXRaster", "value for rasterHueRotate is null")
-          }
-      }
-    }
-
-
-    fun setRasterHueRotateTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterHueRotateTransition(transition);
-      }
-    }
-
-    fun setRasterBrightnessMin(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterBrightnessMin(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterBrightnessMin is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterBrightnessMin(value)
-          } else {
-            e("RNMBXRaster", "value for rasterBrightnessMin is null")
-          }
-      }
-    }
-
-
-    fun setRasterBrightnessMinTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterBrightnessMinTransition(transition);
-      }
-    }
-
-    fun setRasterBrightnessMax(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterBrightnessMax(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterBrightnessMax is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterBrightnessMax(value)
-          } else {
-            e("RNMBXRaster", "value for rasterBrightnessMax is null")
-          }
-      }
-    }
-
-
-    fun setRasterBrightnessMaxTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterBrightnessMaxTransition(transition);
-      }
-    }
-
-    fun setRasterSaturation(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterSaturation(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterSaturation is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterSaturation(value)
-          } else {
-            e("RNMBXRaster", "value for rasterSaturation is null")
-          }
-      }
-    }
-
-
-    fun setRasterSaturationTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterSaturationTransition(transition);
-      }
-    }
-
-    fun setRasterContrast(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterContrast(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterContrast is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterContrast(value)
-          } else {
-            e("RNMBXRaster", "value for rasterContrast is null")
-          }
-      }
-    }
-
-
-    fun setRasterContrastTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterContrastTransition(transition);
-      }
-    }
-
-    fun setRasterResampling(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterResampling(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterResampling is null")
-        }
-      } else {
-          layer.rasterResampling(RasterResampling.valueOf(styleValue.getEnumName()))
-      }
-    }
-
-    fun setRasterFadeDuration(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterFadeDuration(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterFadeDuration is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.rasterFadeDuration(value)
-          } else {
-            e("RNMBXRaster", "value for rasterFadeDuration is null")
-          }
-      }
-    }
-
-    fun setRasterColor(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterColor(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterColor is null")
-        }
-      } else {
-          val value = styleValue.getInt(VALUE_KEY)
-          if (value != null) {
-            layer.rasterColor(value)
-          } else {
-            e("RNMBXRaster", "value for rasterColor is null")
-          }
-      }
-    }
-
-    fun setRasterColorMix(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterColorMix(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterColorMix is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.rasterColorMix(value)
-          } else {
-            e("RNMBXRaster", "value for rasterColorMix is null")
-          }
-      }
-    }
-
-
-    fun setRasterColorMixTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterColorMixTransition(transition);
-      }
-    }
-
-    fun setRasterColorRange(layer: RasterLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.rasterColorRange(expression)
-        } else {
-          e("RNMBXRaster", "Expression for rasterColorRange is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.rasterColorRange(value)
-          } else {
-            e("RNMBXRaster", "value for rasterColorRange is null")
-          }
-      }
-    }
-
-
-    fun setRasterColorRangeTransition(layer: RasterLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.rasterColorRangeTransition(transition);
-      }
-    }
-
-    fun setVisibility(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
-    }
-
-    fun setHillshadeIlluminationDirection(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeIlluminationDirection(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeIlluminationDirection is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.hillshadeIlluminationDirection(value)
-          } else {
-            e("RNMBXHillshade", "value for hillshadeIlluminationDirection is null")
-          }
-      }
-    }
-
-    fun setHillshadeIlluminationAnchor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeIlluminationAnchor(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeIlluminationAnchor is null")
-        }
-      } else {
-          layer.hillshadeIlluminationAnchor(HillshadeIlluminationAnchor.valueOf(styleValue.getEnumName()))
-      }
-    }
-
-    fun setHillshadeExaggeration(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeExaggeration(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeExaggeration is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.hillshadeExaggeration(value)
-          } else {
-            e("RNMBXHillshade", "value for hillshadeExaggeration is null")
-          }
-      }
-    }
-
-
-    fun setHillshadeExaggerationTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.hillshadeExaggerationTransition(transition);
-      }
-    }
-
-    fun setHillshadeShadowColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeShadowColor(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeShadowColor is null")
-        }
-      } else {
-          val value = styleValue.getInt(VALUE_KEY)
-          if (value != null) {
-            layer.hillshadeShadowColor(value)
-          } else {
-            e("RNMBXHillshade", "value for hillshadeShadowColor is null")
-          }
-      }
-    }
-
-
-    fun setHillshadeShadowColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.hillshadeShadowColorTransition(transition);
-      }
-    }
-
-    fun setHillshadeHighlightColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeHighlightColor(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeHighlightColor is null")
-        }
-      } else {
-          val value = styleValue.getInt(VALUE_KEY)
-          if (value != null) {
-            layer.hillshadeHighlightColor(value)
-          } else {
-            e("RNMBXHillshade", "value for hillshadeHighlightColor is null")
-          }
-      }
-    }
-
-
-    fun setHillshadeHighlightColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.hillshadeHighlightColorTransition(transition);
-      }
-    }
-
-    fun setHillshadeAccentColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.hillshadeAccentColor(expression)
-        } else {
-          e("RNMBXHillshade", "Expression for hillshadeAccentColor is null")
-        }
-      } else {
-          val value = styleValue.getInt(VALUE_KEY)
-          if (value != null) {
-            layer.hillshadeAccentColor(value)
-          } else {
-            e("RNMBXHillshade", "value for hillshadeAccentColor is null")
-          }
-      }
-    }
-
-
-    fun setHillshadeAccentColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.hillshadeAccentColorTransition(transition);
-      }
-    }
-
-    fun setVisibility(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
-    }
-
-    fun setModelId(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelId(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelId is null")
-        }
-      } else {
-          val value = styleValue.getString(VALUE_KEY)
-          if (value != null) {
-            layer.modelId(value)
-          } else {
-            e("RNMBXModel", "value for modelId is null")
-          }
-      }
-    }
-
-    fun setModelOpacity(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelOpacity(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelOpacity is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.modelOpacity(value)
-          } else {
-            e("RNMBXModel", "value for modelOpacity is null")
-          }
-      }
-    }
-
-
-    fun setModelOpacityTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelOpacityTransition(transition);
-      }
-    }
-
-    fun setModelRotation(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelRotation(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelRotation is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.modelRotation(value)
-          } else {
-            e("RNMBXModel", "value for modelRotation is null")
-          }
-      }
-    }
-
-
-    fun setModelRotationTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelRotationTransition(transition);
-      }
-    }
-
-    fun setModelScale(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelScale(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelScale is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.modelScale(value)
-          } else {
-            e("RNMBXModel", "value for modelScale is null")
-          }
-      }
-    }
-
-
-    fun setModelScaleTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelScaleTransition(transition);
-      }
-    }
-
-    fun setModelTranslation(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelTranslation(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelTranslation is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.modelTranslation(value)
-          } else {
-            e("RNMBXModel", "value for modelTranslation is null")
+            e("RNMBXHillshade", "value for hillshadeExaggeration is null")
           }
       }
     }
 
 
-    fun setModelTranslationTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
+    fun setHillshadeExaggerationTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.modelTranslationTransition(transition);
+        layer.hillshadeExaggerationTransition(transition);
       }
     }
 
-    fun setModelColor(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
+    fun setHillshadeShadowColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.modelColor(expression)
+          layer.hillshadeShadowColor(expression)
         } else {
-          e("RNMBXModel", "Expression for modelColor is null")
+          e("RNMBXHillshade", "Expression for hillshadeShadowColor is null")
         }
       } else {
           val value = styleValue.getInt(VALUE_KEY)
           if (value != null) {
-            layer.modelColor(value)
-          } else {
-            e("RNMBXModel", "value for modelColor is null")
-          }
-      }
-    }
-
-
-    fun setModelColorTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelColorTransition(transition);
-      }
-    }
-
-    fun setModelColorMixIntensity(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelColorMixIntensity(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelColorMixIntensity is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.modelColorMixIntensity(value)
-          } else {
-            e("RNMBXModel", "value for modelColorMixIntensity is null")
-          }
-      }
-    }
-
-
-    fun setModelColorMixIntensityTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelColorMixIntensityTransition(transition);
-      }
-    }
-
-    fun setModelType(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelType(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelType is null")
-        }
-      } else {
-          layer.modelType(ModelType.valueOf(styleValue.getEnumName()))
-      }
-    }
-
-    fun setModelCastShadows(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelCastShadows(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelCastShadows is null")
-        }
-      } else {
-          val value = styleValue.getBoolean(VALUE_KEY)
-          if (value != null) {
-            layer.modelCastShadows(value)
-          } else {
-            e("RNMBXModel", "value for modelCastShadows is null")
-          }
-      }
-    }
-
-    fun setModelReceiveShadows(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelReceiveShadows(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelReceiveShadows is null")
-        }
-      } else {
-          val value = styleValue.getBoolean(VALUE_KEY)
-          if (value != null) {
-            layer.modelReceiveShadows(value)
-          } else {
-            e("RNMBXModel", "value for modelReceiveShadows is null")
-          }
-      }
-    }
-
-    fun setModelAmbientOcclusionIntensity(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelAmbientOcclusionIntensity(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelAmbientOcclusionIntensity is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.modelAmbientOcclusionIntensity(value)
-          } else {
-            e("RNMBXModel", "value for modelAmbientOcclusionIntensity is null")
-          }
-      }
-    }
-
-
-    fun setModelAmbientOcclusionIntensityTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.modelAmbientOcclusionIntensityTransition(transition);
-      }
-    }
-
-    fun setModelEmissiveStrength(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelEmissiveStrength(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.modelEmissiveStrength(value)
+            layer.hillshadeShadowColor(value)
           } else {
-            e("RNMBXModel", "value for modelEmissiveStrength is null")
+            e("RNMBXHillshade", "value for hillshadeShadowColor is null")
           }
       }
     }
 
 
-    fun setModelEmissiveStrengthTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
+    fun setHillshadeShadowColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.modelEmissiveStrengthTransition(transition);
+        layer.hillshadeShadowColorTransition(transition);
       }
     }
 
-    fun setModelRoughness(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
+    fun setHillshadeHighlightColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.modelRoughness(expression)
+          layer.hillshadeHighlightColor(expression)
         } else {
-          e("RNMBXModel", "Expression for modelRoughness is null")
+          e("RNMBXHillshade", "Expression for hillshadeHighlightColor is null")
         }
       } else {
-          val value = styleValue.getDouble(VALUE_KEY)
+          val value = styleValue.getInt(VALUE_KEY)
           if (value != null) {
-            layer.modelRoughness(value)
+            layer.hillshadeHighlightColor(value)
           } else {
-            e("RNMBXModel", "value for modelRoughness is null")
+            e("RNMBXHillshade", "value for hillshadeHighlightColor is null")
           }
       }
     }
 
 
-    fun setModelRoughnessTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
+    fun setHillshadeHighlightColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.modelRoughnessTransition(transition);
+        layer.hillshadeHighlightColorTransition(transition);
       }
     }
 
-    fun setModelHeightBasedEmissiveStrengthMultiplier(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
+    fun setHillshadeAccentColor(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()
         if (expression != null) {
-          layer.modelHeightBasedEmissiveStrengthMultiplier(expression)
+          layer.hillshadeAccentColor(expression)
         } else {
-          e("RNMBXModel", "Expression for modelHeightBasedEmissiveStrengthMultiplier is null")
+          e("RNMBXHillshade", "Expression for hillshadeAccentColor is null")
         }
       } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
+          val value = styleValue.getInt(VALUE_KEY)
           if (value != null) {
-            layer.modelHeightBasedEmissiveStrengthMultiplier(value)
+            layer.hillshadeAccentColor(value)
           } else {
-            e("RNMBXModel", "value for modelHeightBasedEmissiveStrengthMultiplier is null")
+            e("RNMBXHillshade", "value for hillshadeAccentColor is null")
           }
       }
     }
 
 
-    fun setModelHeightBasedEmissiveStrengthMultiplierTransition(layer: ModelLayer, styleValue: RNMBXStyleValue) {
+    fun setHillshadeAccentColorTransition(layer: HillshadeLayer, styleValue: RNMBXStyleValue) {
       val transition = styleValue.transition
       if (transition != null) {
-        layer.modelHeightBasedEmissiveStrengthMultiplierTransition(transition);
-      }
-    }
-
-    fun setModelCutoffFadeRange(layer: ModelLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.modelCutoffFadeRange(expression)
-        } else {
-          e("RNMBXModel", "Expression for modelCutoffFadeRange is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.modelCutoffFadeRange(value)
-          } else {
-            e("RNMBXModel", "value for modelCutoffFadeRange is null")
-          }
+        layer.hillshadeAccentColorTransition(transition);
       }
     }
 
@@ -4265,32 +3242,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setBackgroundEmissiveStrength(layer: BackgroundLayer, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.backgroundEmissiveStrength(expression)
-        } else {
-          e("RNMBXBackground", "Expression for backgroundEmissiveStrength is null")
-        }
-      } else {
-          val value = styleValue.getDouble(VALUE_KEY)
-          if (value != null) {
-            layer.backgroundEmissiveStrength(value)
-          } else {
-            e("RNMBXBackground", "value for backgroundEmissiveStrength is null")
-          }
-      }
-    }
-
-
-    fun setBackgroundEmissiveStrengthTransition(layer: BackgroundLayer, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.backgroundEmissiveStrengthTransition(transition);
-      }
-    }
-
     fun setVisibility(layer: SkyLayer, styleValue: RNMBXStyleValue ) {
         layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }
@@ -4697,32 +3648,6 @@ object RNMBXStyleFactory {
       }
     }
 
-    fun setVerticalRange(layer: Atmosphere, styleValue: RNMBXStyleValue ) {
-      if (styleValue.isExpression()) {
-        val expression = styleValue.getExpression()
-        if (expression != null) {
-          layer.verticalRange(expression)
-        } else {
-          e("RNMBXAtmosphere", "Expression for verticalRange is null")
-        }
-      } else {
-          val value = styleValue.getFloatArray(VALUE_KEY)
-          if (value != null) {
-            layer.verticalRange(value)
-          } else {
-            e("RNMBXAtmosphere", "value for verticalRange is null")
-          }
-      }
-    }
-
-
-    fun setVerticalRangeTransition(layer: Atmosphere, styleValue: RNMBXStyleValue) {
-      val transition = styleValue.transition
-      if (transition != null) {
-        layer.verticalRangeTransition(transition);
-      }
-    }
-
     fun setExaggeration(layer: Terrain, styleValue: RNMBXStyleValue ) {
       if (styleValue.isExpression()) {
         val expression = styleValue.getExpression()