@rnmapbox/maps 10.1.0-beta.4 → 10.1.0-beta.6

package/android/src/main/{java-v10/com/mapbox/rctmgl/components/styles/RCTMGLStyleFactory.kt → java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt}

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