expo-arcgis 0.1.4 → 0.1.6

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisExtrasModule.kt

@@ -71,6 +71,9 @@ class ExpoArcgisExtrasModule : Module() {
       AsyncFunction("updateAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long, name: String, contentType: String, dataBase64: String ->
         ref.updateAttachment(objectId, attachmentId, name, contentType, dataBase64)
       }
+      AsyncFunction("getServiceGeodatabase") Coroutine { ref: FeatureLayerRef ->
+        ref.getServiceGeodatabase()
+      }
     }
 
     // Per-service token credential — mint a token for a specific URL and add it to the store.
@@ -98,5 +101,28 @@ class ExpoArcgisExtrasModule : Module() {
         ref.switchToNextDestination()
       }
     }
+
+    // Branch versioning — a service geodatabase handle obtained from FeatureLayerRef.getServiceGeodatabase().
+    Class(ServiceGeodatabaseRef::class) {
+      AsyncFunction("fetchVersions") Coroutine { ref: ServiceGeodatabaseRef ->
+        ref.fetchVersions()
+      }
+      AsyncFunction("createVersion") Coroutine { ref: ServiceGeodatabaseRef, params: Map<String, Any?> ->
+        ref.createVersion(params)
+      }
+      AsyncFunction("switchVersion") Coroutine { ref: ServiceGeodatabaseRef, name: String ->
+        ref.switchVersion(name)
+      }
+      AsyncFunction("applyEdits") Coroutine { ref: ServiceGeodatabaseRef ->
+        ref.applyEdits()
+      }
+      AsyncFunction("undoLocalEdits") Coroutine { ref: ServiceGeodatabaseRef ->
+        ref.undoLocalEdits()
+      }
+      Function("hasLocalEdits") { ref: ServiceGeodatabaseRef -> ref.hasLocalEdits() }
+      Function("getVersionName") { ref: ServiceGeodatabaseRef -> ref.getVersionName() }
+      Function("getDefaultVersionName") { ref: ServiceGeodatabaseRef -> ref.getDefaultVersionName() }
+      Function("supportsBranchVersioning") { ref: ServiceGeodatabaseRef -> ref.supportsBranchVersioning() }
+    }
   }
 }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisMapView.kt

@@ -140,6 +140,12 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     scope.launch { mapView.setViewpointAnimated(Viewpoint(lat, lon, scale), 0.5f) }
   }
 
+  /** Sets the coordinate grid overlay from JS (null hides it). */
+  fun setGrid(config: Map<String, Any?>?) {
+    mapView.grid = buildGrid(config)
+      ?: com.arcgismaps.mapping.view.LatitudeLongitudeGrid().apply { isVisible = false }
+  }
+
   /** Enables/configures the device location display from JS (null disables it). */
   fun setLocationDisplay(config: Map<String, Any?>?) {
     val locationDisplay = mapView.locationDisplay
@@ -251,3 +257,17 @@ private fun autoPanMode(mode: String?): LocationDisplayAutoPanMode = when (mode)
   "compassNavigation" -> LocationDisplayAutoPanMode.CompassNavigation
   else -> LocationDisplayAutoPanMode.Off
 }
+
+/// Builds an ArcGIS coordinate grid from a JS config (`{ type, visible? }`); null = no grid.
+/// Shared by `ExpoArcgisMapView` and `ExpoArcgisSceneView`.
+internal fun buildGrid(config: Map<String, Any?>?): com.arcgismaps.mapping.view.Grid? {
+  val type = config?.get("type") as? String ?: return null
+  val grid: com.arcgismaps.mapping.view.Grid = when (type) {
+    "mgrs" -> com.arcgismaps.mapping.view.MgrsGrid()
+    "utm" -> com.arcgismaps.mapping.view.UtmGrid()
+    "usng" -> com.arcgismaps.mapping.view.UsngGrid()
+    else -> com.arcgismaps.mapping.view.LatitudeLongitudeGrid()
+  }
+  (config["visible"] as? Boolean)?.let { grid.isVisible = it }
+  return grid
+}

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisModule.kt

@@ -405,6 +405,10 @@ class ExpoArcgisModule : Module() {
         view.setGeometryEditor(ref)
       }
 
+      Prop("grid") { view: ExpoArcgisMapView, grid: Map<String, Any?>? ->
+        view.setGrid(grid)
+      }
+
       AsyncFunction("identify") { view: ExpoArcgisMapView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
         view.identify(screenPoint, options, promise)
       }
@@ -443,6 +447,10 @@ class ExpoArcgisModule : Module() {
         view.setCameraController(value)
       }
 
+      Prop("grid") { view: ExpoArcgisSceneView, grid: Map<String, Any?>? ->
+        view.setGrid(grid)
+      }
+
       Prop("sunLighting") { view: ExpoArcgisSceneView, value: String? ->
         view.setSunLighting(value)
       }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisSceneView.kt

@@ -167,6 +167,12 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     }
   }
 
+  /** Sets the coordinate grid overlay from JS (null hides it). */
+  fun setGrid(config: Map<String, Any?>?) {
+    sceneView.grid = buildGrid(config)
+      ?: com.arcgismaps.mapping.view.LatitudeLongitudeGrid().apply { isVisible = false }
+  }
+
   /** Sun lighting mode (shadows). */
   fun setSunLighting(s: String?) {
     sceneView.sunLighting = when (s) {

package/android/src/main/java/expo/modules/arcgis/GraphicsOverlayRef.kt

@@ -20,8 +20,10 @@ import com.arcgismaps.mapping.symbology.DistanceCompositeSceneSymbol
 import com.arcgismaps.mapping.symbology.DistanceSymbolRange
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
+import com.arcgismaps.mapping.symbology.MultilayerPointSymbol
 import com.arcgismaps.mapping.symbology.PictureFillSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
+import com.arcgismaps.mapping.symbology.PictureMarkerSymbolLayer
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbolStyle
 import com.arcgismaps.mapping.symbology.SimpleRenderer
@@ -372,6 +374,30 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
     }
     CompositeSymbol(symbolList)
   }
+  "multilayer-point" -> {
+    // Build each picture-marker symbol layer and assemble a MultilayerPointSymbol.
+    // symbolLayers on MultilayerSymbol is a mutable List — populated via the constructor.
+    // DEFER: vector-marker layers (VectorMarkerSymbolLayer) require VectorMarkerSymbolElement
+    //   from geometry+symbol objects and cannot be cleanly constructed from a plain dict; skip.
+    val layerDicts = s["symbolLayers"] as? List<*> ?: emptyList<Any>()
+    val symbolLayers = layerDicts.mapNotNull { ld ->
+      val ldMap = ld as? Map<*, *> ?: return@mapNotNull null
+      when (ldMap["type"]) {
+        "picture-marker" -> {
+          val url = ldMap["url"] as? String ?: return@mapNotNull null
+          PictureMarkerSymbolLayer(url).apply {
+            (ldMap["size"] as? Number)?.toDouble()?.let { size = it }
+            (ldMap["width"] as? Number)?.toDouble()?.let { size = it }
+            (ldMap["height"] as? Number)?.toDouble()?.let { size = it }
+            (ldMap["offsetX"] as? Number)?.toDouble()?.let { offsetX = it }
+            (ldMap["offsetY"] as? Number)?.toDouble()?.let { offsetY = it }
+          }
+        }
+        else -> null
+      }
+    }
+    MultilayerPointSymbol(symbolLayers)
+  }
   else -> null
 }
 

package/android/src/main/java/expo/modules/arcgis/LayerRef.kt

@@ -82,6 +82,9 @@ class FeatureLayerRef(appContext: AppContext, props: Map<String, Any?>) : LayerR
   override val layer: FeatureLayer = FeatureLayer.createWithFeatureTable(table)
   private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
 
+  /** Lazily-built branch-versioning handle for this layer's service geodatabase (cached). */
+  private var cachedServiceGeodatabase: ServiceGeodatabaseRef? = null
+
   /** Returns the features matching `query` (all features when null). Loads attributes in full. */
   suspend fun queryFeatures(query: Map<String, Any?>?): List<Map<String, Any?>> {
     val params = buildQueryParameters(query)
@@ -154,6 +157,23 @@ class FeatureLayerRef(appContext: AppContext, props: Map<String, Any?>) : LayerR
     (table as? ServiceFeatureTable)?.undoLocalEdits()?.getOrThrow()
   }
 
+  /**
+   * Returns the branch-versioning handle for this layer's service geodatabase. Loads the table
+   * first (so the geodatabase is populated). Throws if the layer is not backed by a feature
+   * service. The same handle is returned on repeat calls.
+   */
+  suspend fun getServiceGeodatabase(): ServiceGeodatabaseRef {
+    cachedServiceGeodatabase?.let { return it }
+    val serviceTable = table as? ServiceFeatureTable
+      ?: throw IllegalStateException("Layer is not backed by a service feature table")
+    serviceTable.load().getOrThrow()
+    val geodatabase = serviceTable.serviceGeodatabase
+      ?: throw IllegalStateException("Service geodatabase unavailable for this layer")
+    cachedServiceGeodatabase?.let { return it }  // guard the load race
+    val ctx = appContext ?: throw IllegalStateException("No app context")
+    return ServiceGeodatabaseRef(ctx, geodatabase).also { cachedServiceGeodatabase = it }
+  }
+
   /** Queries features related to `objectId` (across all relationships); returns groups by relationship. */
   suspend fun queryRelatedFeatures(objectId: Long): List<Map<String, Any?>> {
     val arcgisTable = table as? ArcGISFeatureTable ?: return emptyList()

package/android/src/main/java/expo/modules/arcgis/MapRef.kt

@@ -3,6 +3,7 @@ package expo.modules.arcgis
 import com.arcgismaps.geometry.Envelope
 import com.arcgismaps.mapping.ArcGISMap
 import com.arcgismaps.mapping.Basemap
+import com.arcgismaps.mapping.Bookmark
 import com.arcgismaps.mapping.BasemapStyle
 import com.arcgismaps.mapping.BasemapStyleLanguageStrategy
 import com.arcgismaps.mapping.BasemapStyleParameters
@@ -71,6 +72,18 @@ class MapRef(appContext: AppContext, portalItem: Map<String, Any?>? = null) : Sh
             map.initialViewpoint = Viewpoint(lat, lon, scale)
           }
         }
+        "bookmarks" -> (value as? List<*>)?.let { entries ->
+          map.bookmarks.clear()
+          for (entry in entries) {
+            val e = entry as? Map<*, *> ?: continue
+            val name = e["name"] as? String ?: continue
+            val vp = e["viewpoint"] as? Map<*, *> ?: continue
+            val lat = (vp["latitude"] as? Number)?.toDouble() ?: continue
+            val lon = (vp["longitude"] as? Number)?.toDouble() ?: continue
+            val scale = (vp["scale"] as? Number)?.toDouble() ?: continue
+            map.bookmarks.add(Bookmark(name, Viewpoint(lat, lon, scale)))
+          }
+        }
         "mobileMapPackagePath" -> (value as? String)?.let { loadMobileMapPackage(it) }
         "referenceScale" -> (value as? Number)?.let { map.referenceScale = it.toDouble() }
         "maxExtent" -> (value as? Map<*, *>)?.let { dict ->

package/android/src/main/java/expo/modules/arcgis/SceneRef.kt

@@ -4,6 +4,7 @@ import com.arcgismaps.geometry.Point
 import com.arcgismaps.geometry.SpatialReference
 import com.arcgismaps.mapping.ArcGISScene
 import com.arcgismaps.mapping.ArcGISTiledElevationSource
+import com.arcgismaps.mapping.Bookmark
 import com.arcgismaps.mapping.Basemap
 import com.arcgismaps.mapping.BasemapStyle
 import com.arcgismaps.mapping.MobileScenePackage
@@ -80,6 +81,18 @@ class SceneRef(appContext: AppContext, portalItem: Map<String, Any?>? = null) :
             scene.initialViewpoint = Viewpoint(point, camera)
           }
         }
+        "bookmarks" -> (value as? List<*>)?.let { entries ->
+          scene.bookmarks.clear()
+          for (entry in entries) {
+            val e = entry as? Map<*, *> ?: continue
+            val name = e["name"] as? String ?: continue
+            val vp = e["viewpoint"] as? Map<*, *> ?: continue
+            val lat = (vp["latitude"] as? Number)?.toDouble() ?: continue
+            val lon = (vp["longitude"] as? Number)?.toDouble() ?: continue
+            val scale = (vp["scale"] as? Number)?.toDouble() ?: continue
+            scene.bookmarks.add(Bookmark(name, Viewpoint(lat, lon, scale)))
+          }
+        }
         "mobileScenePackagePath" -> (value as? String)?.let { loadMobileScenePackage(it) }
       }
     }

package/android/src/main/java/expo/modules/arcgis/ServiceGeodatabaseRef.kt

@@ -0,0 +1,78 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.arcgisservices.ServiceVersionInfo
+import com.arcgismaps.arcgisservices.ServiceVersionParameters
+import com.arcgismaps.arcgisservices.VersionAccess
+import com.arcgismaps.data.ServiceGeodatabase
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.sharedobjects.SharedObject
+
+/**
+ * Branch-versioning handle over a [ServiceGeodatabase]. Built by `FeatureLayerRef.getServiceGeodatabase()`
+ * (never constructed from JS). Manages named branch versions and pushes the service-wide local edits
+ * (across every connected table) to the active version.
+ */
+class ServiceGeodatabaseRef(appContext: AppContext, private val geodatabase: ServiceGeodatabase) :
+  SharedObject(appContext) {
+
+  /** Lists every branch version defined on the service. */
+  suspend fun fetchVersions(): List<Map<String, Any?>> =
+    geodatabase.fetchVersions().getOrThrow().map { serializeVersionInfo(it) }
+
+  /** Creates a new branch version from `{ name, description?, access? }` and returns its info. */
+  suspend fun createVersion(params: Map<String, Any?>): Map<String, Any?> {
+    val parameters = ServiceVersionParameters().apply {
+      (params["name"] as? String)?.let { name = it }
+      (params["description"] as? String)?.let { description = it }
+      access = versionAccess(params["access"] as? String)
+    }
+    return serializeVersionInfo(geodatabase.createVersion(parameters).getOrThrow())
+  }
+
+  /** Switches the active version (requires no outstanding local edits). */
+  suspend fun switchVersion(name: String) {
+    geodatabase.switchVersion(name).getOrThrow()
+  }
+
+  /** Pushes all connected tables' local edits to the active version; returns each edit's result. */
+  suspend fun applyEdits(): List<Map<String, Any?>> =
+    geodatabase.applyEdits().getOrThrow().flatMap { it.editResults }.map {
+      mapOf("objectId" to it.objectId, "completedWithErrors" to it.completedWithErrors)
+    }
+
+  /** Discards all local edits across the connected tables. */
+  suspend fun undoLocalEdits() {
+    geodatabase.undoLocalEdits().getOrThrow()
+  }
+
+  fun hasLocalEdits(): Boolean = geodatabase.hasLocalEdits()
+  fun getVersionName(): String = geodatabase.versionName
+  fun getDefaultVersionName(): String = geodatabase.defaultVersionName
+  fun supportsBranchVersioning(): Boolean = geodatabase.supportsBranchVersioning
+}
+
+/** Serializes a [ServiceVersionInfo] to a JS-friendly map. */
+private fun serializeVersionInfo(info: ServiceVersionInfo): Map<String, Any?> {
+  val dict = mutableMapOf<String, Any?>(
+    "name" to info.name,
+    "description" to info.description,
+    "access" to accessString(info.access),
+    "isOwner" to info.isOwner,
+  )
+  info.versionId?.toString()?.let { dict["versionId"] = it }
+  return dict
+}
+
+/** Native [VersionAccess] -> JS string. */
+private fun accessString(access: VersionAccess): String = when (access) {
+  is VersionAccess.Protected -> "protected"
+  is VersionAccess.Private -> "private"
+  else -> "public"
+}
+
+/** JS string -> native [VersionAccess] (defaults to public). */
+private fun versionAccess(string: String?): VersionAccess = when (string) {
+  "protected" -> VersionAccess.Protected
+  "private" -> VersionAccess.Private
+  else -> VersionAccess.Public
+}

package/build/DynamicEntityLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAO5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwD2i3B,CAAC;gBAAkB,CAAC;;;;;;;4DAD7l3B,CAAC"}
+{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAO5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwD489B,CAAC;gBAAkB,CAAC;;;;;;;4DAD9/9B,CAAC"}

package/build/ExpoArcgis.types.d.ts

@@ -63,6 +63,19 @@ export type MapProps = {
      * map appears once ready.
      */
     mobileMapPackagePath?: string;
+    /**
+     * Named saved viewpoints stored on the map. Replaces the map's bookmark list each time the prop
+     * changes. Each entry creates a native `Bookmark(name, Viewpoint(latitude, longitude, scale))`.
+     * Navigation to a bookmark is done separately via the `<MapView viewpoint>` prop.
+     */
+    bookmarks?: {
+        name: string;
+        viewpoint: {
+            latitude: number;
+            longitude: number;
+            scale: number;
+        };
+    }[];
 };
 export type MapLoadedEventPayload = {
     /** WKID of the loaded map's spatial reference, or null if unavailable. */
@@ -134,6 +147,15 @@ export type MapViewProps = {
     onLocationChange?: (event: {
         nativeEvent: LocationEventPayload;
     }) => void;
+    /** Coordinate-grid overlay (MGRS / UTM / USNG / latitude-longitude). `null` / omitted = none. */
+    grid?: GridConfig | null;
+};
+/** A coordinate-grid overlay for a `<MapView>` / `<SceneView>`. */
+export type GridConfig = {
+    /** Grid type: military grid (MGRS), UTM, US National Grid, or latitude-longitude. */
+    type: 'mgrs' | 'utm' | 'usng' | 'latitude-longitude';
+    /** Whether the grid is drawn. Defaults to `true`. */
+    visible?: boolean;
 };
 /** Common operational-layer props (subset of ArcGIS layer properties). */
 export type LayerProps = {
@@ -520,6 +542,63 @@ export type FeatureLayerHandle = {
      * @param dataBase64 New base64-encoded file contents.
      */
     updateAttachment(objectId: number, attachmentId: number, name: string, contentType: string, dataBase64: string): Promise<void>;
+    /**
+     * Returns the branch-versioning handle for this layer's service geodatabase (ArcGIS Enterprise
+     * branch-versioned services only). Loads the table first; rejects if the layer is not a service
+     * feature layer. The same handle is returned on repeat calls.
+     */
+    getServiceGeodatabase(): Promise<ServiceGeodatabaseHandle>;
+};
+/** Branch-version access level. */
+export type VersionAccess = 'public' | 'protected' | 'private';
+/** Metadata for one branch version of a service geodatabase. */
+export type ServiceVersionInfo = {
+    /** Fully-qualified version name (e.g. `"OWNER.versionName"`). */
+    name: string;
+    /** Free-text description. */
+    description: string;
+    /** Who may see / edit the version. */
+    access: VersionAccess;
+    /** Whether the current user owns this version. */
+    isOwner: boolean;
+    /** Server-assigned version GUID, when available. */
+    versionId?: string;
+};
+/** Parameters for creating a new branch version. */
+export type CreateVersionParams = {
+    /** Short version name (the server prefixes the owner). */
+    name: string;
+    /** Optional description. */
+    description?: string;
+    /** Access level. Defaults to `"public"`. */
+    access?: VersionAccess;
+};
+/**
+ * Handle to a service geodatabase's branch-versioning surface, from
+ * `FeatureLayerHandle.getServiceGeodatabase()`. Manages named versions and pushes the service-wide
+ * local edits (across every connected table) to the active version. Edit features through the
+ * `<FeatureLayer>` handle with `apply: false`, then call `applyEdits()` here to push them — distinct
+ * from the table-level `FeatureLayerHandle.applyEdits()`, which pushes only this layer's table.
+ */
+export type ServiceGeodatabaseHandle = {
+    /** Lists all branch versions on the service. */
+    fetchVersions(): Promise<ServiceVersionInfo[]>;
+    /** Creates a new branch version and resolves with its info. */
+    createVersion(params: CreateVersionParams): Promise<ServiceVersionInfo>;
+    /** Switches the active version (rejects if there are outstanding local edits). */
+    switchVersion(name: string): Promise<void>;
+    /** Pushes all connected tables' local edits to the active version in one batch. */
+    applyEdits(): Promise<EditResult[]>;
+    /** Discards all local edits across connected tables. */
+    undoLocalEdits(): Promise<void>;
+    /** Whether any connected table has unsaved local edits. */
+    hasLocalEdits(): boolean;
+    /** The active version's name. */
+    getVersionName(): string;
+    /** The default version name (e.g. `"sde.DEFAULT"`). */
+    getDefaultVersionName(): string;
+    /** Whether the service supports branch versioning. */
+    supportsBranchVersioning(): boolean;
 };
 /** A label rule for a `<FeatureLayer>` — mirrors the native `LabelDefinition`. */
 export type LabelDefinition = {
@@ -1588,8 +1667,54 @@ export type CompositeSymbolType = {
     /** The symbols to stack, drawn in order (first = bottom, last = top). */
     symbols: Symbol[];
 };
+/**
+ * One picture-marker symbol layer within a `MultilayerPointSymbolType`.
+ * Mirrors the native `PictureMarkerSymbolLayer`.
+ *
+ * NOTE: `size` sets a uniform size (overrides `width`/`height` when all three are supplied).
+ * `width` and `height` are applied in order, so supplying both sets size to the last one;
+ * use `size` for a uniform value. `offsetX`/`offsetY` shift the layer in points.
+ *
+ * DEFER: `VectorMarkerSymbolLayer` (the vector-marker kind) requires constructing
+ * `VectorMarkerSymbolElement` objects from geometry + symbol objects, which cannot be
+ * expressed as a plain flat dict. It is not yet implemented.
+ */
+export type PictureMarkerSymbolLayerSpec = {
+    type: 'picture-marker';
+    /** Image URL (remote `http(s)` or a local file URL). */
+    url: string;
+    /** Uniform size in points (sets both width and height). */
+    size?: number;
+    /** Display width in points. */
+    width?: number;
+    /** Display height in points. */
+    height?: number;
+    /** Horizontal offset of the layer, in points. */
+    offsetX?: number;
+    /** Vertical offset of the layer, in points. */
+    offsetY?: number;
+};
+/** Union of all supported symbol layer kinds within a `MultilayerPointSymbolType`. */
+export type SymbolLayerSpec = PictureMarkerSymbolLayerSpec;
+/**
+ * A multilayer point symbol composed of one or more symbol layers.
+ * Mirrors the native `MultilayerPointSymbol`. Useful for rich point icons built from stacked
+ * picture images (e.g. a pin body + a badge overlay at different offsets).
+ *
+ * @example
+ * ```ts
+ * { type: 'multilayer-point', symbolLayers: [
+ *   { type: 'picture-marker', url: 'https://example.com/pin.png', width: 30, height: 30 },
+ * ] }
+ * ```
+ */
+export type MultilayerPointSymbolType = {
+    type: 'multilayer-point';
+    /** The symbol layers to compose, rendered in list order. */
+    symbolLayers: SymbolLayerSpec[];
+};
 /** Any symbol usable by a `<Graphic>`. Mirrors the native `Symbol` hierarchy. */
-export type Symbol = SimpleMarkerSymbol | SimpleLineSymbol | SimpleFillSymbol | TextSymbol | SimpleMarkerSceneSymbol | PictureMarkerSymbol | PictureFillSymbol | DistanceCompositeSceneSymbol | CompositeSymbolType;
+export type Symbol = SimpleMarkerSymbol | SimpleLineSymbol | SimpleFillSymbol | TextSymbol | SimpleMarkerSceneSymbol | PictureMarkerSymbol | PictureFillSymbol | DistanceCompositeSceneSymbol | CompositeSymbolType | MultilayerPointSymbolType;
 /** One stop in a `SizeVisualVariable` stops array. */
 export type SizeStop = {
     value: number;
@@ -1774,6 +1899,19 @@ export type SceneProps = {
     portalItem?: PortalItem;
     /** Local path to a mobile scene package (`.mspk`); its first scene is shown when loaded. */
     mobileScenePackagePath?: string;
+    /**
+     * Named saved viewpoints stored on the scene. Replaces the scene's bookmark list each time the
+     * prop changes. Each entry creates a native `Bookmark(name, Viewpoint(latitude, longitude, scale))`.
+     * Navigation to a bookmark is done separately via the `<SceneView camera>` prop.
+     */
+    bookmarks?: {
+        name: string;
+        viewpoint: {
+            latitude: number;
+            longitude: number;
+            scale: number;
+        };
+    }[];
 };
 /** Sun lighting mode for a 3D scene view (controls shadows). */
 export type SunLighting = 'off' | 'light' | 'lightAndShadows';
@@ -1804,6 +1942,8 @@ export type SceneViewProps = {
      * - `{ type: 'globe' }` — free globe navigation.
      */
     cameraController?: CameraController | null;
+    /** Coordinate-grid overlay (MGRS / UTM / USNG / latitude-longitude). `null` / omitted = none. */
+    grid?: GridConfig | null;
     /** Sun lighting mode (shadows). Defaults to `off`. */
     sunLighting?: SunLighting;
     /** Atmosphere rendering. Defaults to `horizonOnly`. */