expo-arcgis 0.1.9 → 0.2.1

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

@@ -44,6 +44,12 @@ class ExpoArcgisExtrasModule : Module() {
       AsyncFunction("addFeatureWithTemplate") Coroutine { ref: FeatureLayerRef, templateName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean? ->
         ref.addFeatureWithTemplate(templateName, attributes, geometry, apply)
       }
+      AsyncFunction("addFeatureWithSubtype") Coroutine { ref: FeatureLayerRef, subtypeName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean? ->
+        ref.addFeatureWithSubtype(subtypeName, attributes, geometry, apply)
+      }
+      AsyncFunction("getContingentValues") Coroutine { ref: FeatureLayerRef, objectId: Long, fieldName: String ->
+        ref.getContingentValues(objectId, fieldName)
+      }
       AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?>, apply: Boolean? ->
         ref.updateFeature(objectId, changes, apply)
       }
@@ -180,5 +186,14 @@ class ExpoArcgisExtrasModule : Module() {
         ref.validateNetworkTopology(extent)
       }
     }
+
+    // Georeferenced image overlay (added to a <MapView> via <ImageOverlay>).
+    Class(ImageOverlayRef::class) {
+      Constructor { ImageOverlayRef(appContext) }
+      Function("setFrame") { ref: ImageOverlayRef, imagePath: String, extent: Map<String, Any?>, opacity: Double? ->
+        ref.setFrame(imagePath, extent, opacity)
+      }
+      Function("setOpacity") { ref: ImageOverlayRef, opacity: Double -> ref.setOpacity(opacity) }
+    }
   }
 }

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

@@ -181,6 +181,14 @@ class ExpoArcgisGeometryModule : Module() {
       ArcGISEnvironment.authenticationManager.arcGISCredentialStore.removeAll()
     }
 
+    // Portal — search a Portal and fetch basemaps, exposed as the JS `portal` namespace.
+    AsyncFunction("portalFindItems") Coroutine { params: Map<String, Any?> ->
+      portalFindItems(params)
+    }
+    AsyncFunction("portalFetchBasemaps") Coroutine { params: Map<String, Any?> ->
+      portalFetchBasemaps(params)
+    }
+
     // Offline — take maps/data offline, exposed as the JS `offline` namespace.
     AsyncFunction("generateOfflineMap") Coroutine { portalItemId: String, areaOfInterest: Map<String, Any?>, downloadName: String, overrides: Map<String, Any?>? ->
       generateOfflineMap(appContext, appContext.reactContext?.filesDir, portalItemId, areaOfInterest, downloadName, overrides)

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

@@ -131,6 +131,11 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     mapView.graphicsOverlays.addAll(refs.map { it.overlay })
   }
 
+  fun setImageOverlays(refs: List<ImageOverlayRef>) {
+    mapView.imageOverlays.clear()
+    mapView.imageOverlays.addAll(refs.map { it.overlay })
+  }
+
   /** Animates the view to a runtime viewpoint sent from JS. */
   fun setViewpoint(vp: Map<String, Any?>?) {
     vp ?: return

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

@@ -224,6 +224,7 @@ class ExpoArcgisModule : Module() {
       Function("applyProps") { ref: KmlLayerRef, changed: Map<String, Any?> ->
         ref.applyProps(changed)
       }
+      AsyncFunction("getNodes") Coroutine { ref: KmlLayerRef -> ref.getNodes() }
     }
 
     // WFS (Web Feature Service) + OGC API - Features — feature layers over async-populating tables.
@@ -364,6 +365,10 @@ class ExpoArcgisModule : Module() {
         view.setGraphicsOverlays(refs)
       }
 
+      Prop("imageOverlays") { view: ExpoArcgisMapView, refs: List<ImageOverlayRef> ->
+        view.setImageOverlays(refs)
+      }
+
       Prop("viewpoint") { view: ExpoArcgisMapView, vp: Map<String, Any?>? ->
         view.setViewpoint(vp)
       }
@@ -450,6 +455,10 @@ class ExpoArcgisModule : Module() {
         view.retryLoad(promise)
       }
 
+      AsyncFunction("getElevation") { view: ExpoArcgisSceneView, point: Map<String, Any?>, promise: Promise ->
+        view.getElevation(point, promise)
+      }
+
       AsyncFunction("identify") { view: ExpoArcgisSceneView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
         view.identify(screenPoint, options, promise)
       }

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

@@ -132,6 +132,17 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     }
   }
 
+  /** Returns the terrain elevation (meters) at a point on the scene's base surface, or null. */
+  fun getElevation(point: Map<String, Any?>, promise: Promise) {
+    val scene = sceneView.scene ?: run { promise.resolve(null); return }
+    val p = geometryFromDict(point) as? Point ?: run { promise.resolve(null); return }
+    scope.launch {
+      scene.baseSurface.getElevation(p)
+        .onSuccess { promise.resolve(it) }
+        .onFailure { e -> promise.reject("ELEVATION_ERROR", e.message ?: "Elevation query failed", e) }
+    }
+  }
+
   /** Animates the view to a runtime camera sent from JS. */
   fun setCamera(c: Map<String, Any?>?) {
     val position = c?.get("position") as? Map<*, *> ?: return

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

@@ -22,6 +22,7 @@ import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
 import com.arcgismaps.mapping.symbology.MultilayerPointSymbol
 import com.arcgismaps.mapping.symbology.MultilayerPolygonSymbol
+import com.arcgismaps.mapping.symbology.MultilayerPolylineSymbol
 import com.arcgismaps.mapping.symbology.PictureFillSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbolLayer
@@ -397,20 +398,39 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
           }
         }
         "vector-marker" -> {
-          // DEFER: polyline / multipoint element geometries are not yet supported — only polygon.
           val geomMap = ldMap["geometry"] as? Map<*, *> ?: return@mapNotNull null
-          if (geomMap["type"] != "polygon") return@mapNotNull null
           val geom = geometryFromDict(geomMap) ?: return@mapNotNull null
-          val fillColor = colorOf(ldMap["fillColor"]) ?: Color.fromRgba(255, 0, 0, 255)
-          val elementLayers = buildList {
-            add(SolidFillSymbolLayer(fillColor))
-            colorOf(ldMap["outlineColor"])?.let { outlineColor ->
-              val outlineWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
-              add(SolidStrokeSymbolLayer(outlineWidth, outlineColor))
+          val elementSymbol = when (geomMap["type"]) {
+            "polygon" -> {
+              val fillColor = colorOf(ldMap["fillColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val elementLayers = buildList {
+                add(SolidFillSymbolLayer(fillColor))
+                colorOf(ldMap["outlineColor"])?.let { outlineColor ->
+                  val outlineWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+                  add(SolidStrokeSymbolLayer(outlineWidth, outlineColor))
+                }
+              }
+              MultilayerPolygonSymbol(elementLayers)
             }
+            "polyline" -> {
+              val strokeColor = colorOf(ldMap["fillColor"]) ?: colorOf(ldMap["outlineColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val strokeWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+              MultilayerPolylineSymbol(listOf(SolidStrokeSymbolLayer(strokeWidth, strokeColor)))
+            }
+            "multipoint" -> {
+              val fillColor = colorOf(ldMap["fillColor"]) ?: Color.fromRgba(255, 0, 0, 255)
+              val elementLayers = buildList {
+                add(SolidFillSymbolLayer(fillColor))
+                colorOf(ldMap["outlineColor"])?.let { outlineColor ->
+                  val outlineWidth = (ldMap["outlineWidth"] as? Number)?.toDouble() ?: 1.0
+                  add(SolidStrokeSymbolLayer(outlineWidth, outlineColor))
+                }
+              }
+              MultilayerPointSymbol(elementLayers)
+            }
+            else -> return@mapNotNull null // unsupported geometry type — skip gracefully
           }
-          val fillSymbol = MultilayerPolygonSymbol(elementLayers)
-          val element = VectorMarkerSymbolElement(geom, fillSymbol)
+          val element = VectorMarkerSymbolElement(geom, elementSymbol)
           VectorMarkerSymbolLayer(listOf(element)).apply {
             (ldMap["size"] as? Number)?.toDouble()?.let { size = it }
           }

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

@@ -0,0 +1,28 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.geometry.Envelope
+import com.arcgismaps.mapping.view.ImageFrame
+import com.arcgismaps.mapping.view.ImageOverlay
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.sharedobjects.SharedObject
+
+/**
+ * An [ImageOverlay] that displays a single georeferenced image frame — a local image file shown at a
+ * map extent, with adjustable opacity. Added to a `<MapView>` via the `<ImageOverlay>` component.
+ */
+class ImageOverlayRef(appContext: AppContext) : SharedObject(appContext) {
+  val overlay = ImageOverlay()
+
+  /** Sets the displayed frame from a local image file path and its geographic extent (clears on null). */
+  fun setFrame(imagePath: String, extent: Map<String, Any?>, opacity: Double?) {
+    val envelope = geometryFromDict(extent + ("type" to "envelope")) as? Envelope
+    if (envelope == null) {
+      overlay.imageFrame = null
+      return
+    }
+    overlay.imageFrame = ImageFrame(imagePath, envelope)
+    opacity?.let { overlay.opacity = it.toFloat() }
+  }
+
+  fun setOpacity(opacity: Double) { overlay.opacity = opacity.toFloat() }
+}

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

@@ -3,6 +3,9 @@ package expo.modules.arcgis
 import android.util.Base64
 import com.arcgismaps.data.ArcGISFeature
 import com.arcgismaps.data.ArcGISFeatureTable
+import com.arcgismaps.data.ContingentCodedValue
+import com.arcgismaps.data.ContingentRangeValue
+import com.arcgismaps.data.ContingentValue
 import com.arcgismaps.data.Feature
 import com.arcgismaps.data.FeatureCollection
 import com.arcgismaps.data.FeatureCollectionTable
@@ -51,7 +54,9 @@ import com.arcgismaps.mapping.layers.WebTiledLayer
 import com.arcgismaps.mapping.layers.KmlLayer
 import com.arcgismaps.mapping.layers.WmsLayer
 import com.arcgismaps.mapping.layers.WmtsLayer
+import com.arcgismaps.mapping.kml.KmlContainer
 import com.arcgismaps.mapping.kml.KmlDataset
+import com.arcgismaps.mapping.kml.KmlNode
 import com.arcgismaps.mapping.view.Graphic
 import com.arcgismaps.raster.ImageServiceRaster
 import com.arcgismaps.raster.Raster
@@ -136,6 +141,26 @@ class FeatureLayerRef(appContext: AppContext, private val table: FeatureTable) :
     return persistEdits()
   }
 
+  /**
+   * Adds a feature created from the named subtype (sets the subtype field and inherits its
+   * default attribute values), then optionally applies [attributes] on top and sets [geometry].
+   * When [apply] is not `false`, pushes the edit and returns the new object id; pass
+   * `apply = false` for a local-only edit.
+   */
+  suspend fun addFeatureWithSubtype(subtypeName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean?): Long? {
+    table.load().getOrThrow()
+    val arcGISTable = table as? ArcGISFeatureTable
+      ?: throw IllegalStateException("addFeatureWithSubtype requires an ArcGIS feature table (not a shapefile or WFS table)")
+    val subtype = arcGISTable.featureSubtypes.firstOrNull { it.name == subtypeName }
+      ?: throw IllegalArgumentException("No feature subtype named '$subtypeName' found in the table")
+    val geom = geometry?.let { geometryFromDict(it) }
+    val feature = arcGISTable.createFeature(subtype, geom)
+    if (attributes != null) applyAttributes(feature, attributes)
+    table.addFeature(feature).getOrThrow()
+    if (apply == false) return null
+    return persistEdits()
+  }
+
   /**
    * Adds a feature. When `apply` is not `false`, pushes the edit and returns the new object id;
    * pass `apply = false` to make a local-only edit (batch with `applyEdits`).
@@ -265,6 +290,54 @@ class FeatureLayerRef(appContext: AppContext, private val table: FeatureTable) :
     persistEdits()
   }
 
+  /**
+   * Returns the valid contingent values for [fieldName] on the feature with [objectId].
+   * Requires the table to be an [ArcGISFeatureTable]; throws otherwise. Returns an empty list when
+   * the feature is not found or the table has no contingent-values result for that field.
+   * Result shape: `{ fieldName, contingentValues: [{ type, ... }] }` where each entry is either
+   * `{ type: "coded", fieldGroupName, codedValue: { name, code } }` or
+   * `{ type: "range", fieldGroupName, min, max }`.
+   * Exotic subtypes are serialized as `{ type: "any" }` / `{ type: "null" }`.
+   */
+  suspend fun getContingentValues(objectId: Long, fieldName: String): Map<String, Any?> {
+    table.load().getOrThrow()
+    val arcGISTable = table as? ArcGISFeatureTable
+      ?: throw IllegalStateException("getContingentValues requires an ArcGIS feature table (not a shapefile or WFS table)")
+    val feature = featureByObjectId(objectId) as? ArcGISFeature
+      ?: throw IllegalArgumentException("Feature not found for objectId $objectId")
+    val result = arcGISTable.getContingentValuesOrNull(feature, fieldName)
+      ?: return mapOf("fieldName" to fieldName, "contingentValues" to emptyList<Map<String, Any?>>())
+    val serialized = result.byFieldGroup.flatMap { (groupName, values) ->
+      values.map { cv -> serializeContingentValue(cv, groupName) }
+    }
+    return mapOf("fieldName" to fieldName, "contingentValues" to serialized)
+  }
+
+  private fun serializeContingentValue(cv: ContingentValue, groupName: String): Map<String, Any?> {
+    val dict = mutableMapOf<String, Any?>("fieldGroupName" to groupName)
+    when (cv) {
+      is ContingentCodedValue -> {
+        dict["type"] = "coded"
+        val coded = cv.codedValue
+        dict["codedValue"] = mapOf("name" to coded.name, "code" to coded.code)
+      }
+      is ContingentRangeValue -> {
+        dict["type"] = "range"
+        dict["min"] = cv.minValue
+        dict["max"] = cv.maxValue
+      }
+      else -> {
+        // ContingentNullValue, ContingentAnyValue, or unknown future subtype
+        val typeName = cv::class.simpleName ?: ""
+        dict["type"] = when {
+          typeName.contains("Null", ignoreCase = true) -> "null"
+          else -> "any"
+        }
+      }
+    }
+    return dict
+  }
+
   private suspend fun featureByObjectId(objectId: Long): Feature? {
     val params = QueryParameters().apply { objectIds.add(objectId) }
     return table.queryFeatures(params).getOrThrow().firstOrNull()
@@ -477,9 +550,29 @@ private fun rasterFromSource(s: Map<String, Any?>): Raster =
 
 /** Operational KML layer from a remote .kml/.kmz URL or local file. */
 class KmlLayerRef(appContext: AppContext, url: String) : LayerRef(appContext) {
-  override val layer: KmlLayer = KmlLayer(KmlDataset(url))
+  private val dataset = KmlDataset(url)
+  override val layer: KmlLayer = KmlLayer(dataset)
 
   override fun applyProps(changed: Map<String, Any?>) = applyCommonProps(changed)
+
+  /** Loads the KML and returns its node tree (recursing into container nodes like documents / folders). */
+  suspend fun getNodes(): List<Map<String, Any?>> {
+    dataset.load().getOrThrow()
+    return dataset.rootNodes.map { serializeKmlNode(it) }
+  }
+}
+
+/** Serializes a KML node, recursing into container nodes (documents / folders). */
+private fun serializeKmlNode(node: KmlNode): Map<String, Any?> {
+  val dict = mutableMapOf<String, Any?>(
+    "name" to node.name,
+    "visible" to node.isVisible,
+    "type" to (node::class.simpleName ?: "KmlNode"),
+  )
+  if (node is KmlContainer) {
+    dict["children"] = node.childNodes.map { serializeKmlNode(it) }
+  }
+  return dict
 }
 
 /** Operational WFS layer — a [FeatureLayer] over a [WfsFeatureTable] (Web Feature Service). */

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

@@ -0,0 +1,95 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.mapping.Basemap
+import com.arcgismaps.mapping.PortalItem
+import com.arcgismaps.portal.Portal
+import com.arcgismaps.portal.PortalQueryParameters
+
+/**
+ * Free functions backing the JS `portal` namespace — search a Portal and fetch its basemaps.
+ * Registered as `AsyncFunction`s in `ExpoArcgisGeometryModule`.
+ *
+ * Both functions run anonymously (no auth). Authenticated portals would need a credential
+ * already present in `ArcGISEnvironment.authenticationManager.arcGISCredentialStore`
+ * (e.g. set via `setServiceCredential` / the auth namespace). That is out of scope here.
+ */
+
+/**
+ * Serialises a [PortalItem] to the wire map `{ id, title, type, snippet, owner, thumbnailUrl }`.
+ *
+ * Kotlin SDK notes:
+ *   - `PortalItem.itemId: String` — the item's portal id
+ *   - `PortalItem.title: String` — inherited from `Item`
+ *   - `PortalItem.typeName: String` — human-readable type string (e.g. `"Web Map"`)
+ *   - `PortalItem.snippet: String` — inherited from `Item`
+ *   - `PortalItem.owner: String`
+ *   - `PortalItem.thumbnail: LoadableImage?` — has `getUri(): String?` (relative or absolute URL)
+ *
+ * Thumbnail handling: `LoadableImage.uri` may be a relative path (e.g.
+ * `"thumbnail/thumbnail.png"`) or an absolute URL. We build the canonical ArcGIS REST
+ * thumbnail URL from the portal URL + item id so callers always get an absolute URL.
+ * We do NOT load the image here — that would require an extra async fetch per item;
+ * callers that need the bitmap should load the URL themselves.
+ */
+private fun portalItemToMap(item: PortalItem): Map<String, Any?> {
+  val portalUrl = item.portal.url.trimEnd('/')
+  val thumbnailUrl = if (item.itemId.isNotEmpty()) {
+    "$portalUrl/sharing/rest/content/items/${item.itemId}/info/thumbnail"
+  } else {
+    null
+  }
+  return mapOf(
+    "id" to item.itemId,
+    "title" to item.title,
+    "type" to item.typeName,
+    "snippet" to item.snippet,
+    "owner" to item.owner,
+    "thumbnailUrl" to thumbnailUrl,
+  )
+}
+
+/**
+ * Searches the portal at [portalUrl] (default ArcGIS Online) with the given [query] string,
+ * returning up to [max] results (default 10).
+ *
+ * Kotlin SDK signatures used:
+ *   - `Portal(url: String, connection: Portal.Connection)` — `Portal.Connection.Anonymous`
+ *   - `portal.load(): Result<Unit>` — must be called before queries
+ *   - `portal.findItems(PortalQueryParameters): Result<PortalQueryResultSet<PortalItem>>`
+ *   - `PortalQueryParameters(query: String, boundingBox: Envelope?, limit: Int)`
+ *     where the primary ctor is `(String, Envelope?, Int)` and `limit` defaults to 10.
+ */
+internal suspend fun portalFindItems(params: Map<String, Any?>): List<Map<String, Any?>> {
+  val urlString = params["portalUrl"] as? String ?: "https://www.arcgis.com"
+  val query = params["query"] as? String ?: ""
+  val max = (params["max"] as? Number)?.toInt() ?: 10
+
+  val portal = Portal(urlString, Portal.Connection.Anonymous)
+  portal.load().getOrThrow()
+
+  val queryParams = PortalQueryParameters(query, null, max)
+  val resultSet = portal.findItems(queryParams).getOrThrow()
+  return resultSet.results.map { portalItemToMap(it) }
+}
+
+/**
+ * Fetches the organisation basemaps from the portal at [portalUrl] (default ArcGIS Online).
+ * Returns `[{ name, itemId }]`.
+ *
+ * Kotlin SDK signatures used:
+ *   - `portal.fetchBasemaps(): Result<List<Basemap>>`
+ *   - `Basemap.name: String`
+ *   - `Basemap.item: Item?` — cast to `PortalItem` to get the item id
+ */
+internal suspend fun portalFetchBasemaps(params: Map<String, Any?>): List<Map<String, Any?>> {
+  val urlString = params["portalUrl"] as? String ?: "https://www.arcgis.com"
+
+  val portal = Portal(urlString, Portal.Connection.Anonymous)
+  portal.load().getOrThrow()
+
+  val basemaps: List<Basemap> = portal.fetchBasemaps().getOrThrow()
+  return basemaps.map { basemap ->
+    val itemId = (basemap.item as? PortalItem)?.itemId
+    mapOf("name" to basemap.name, "itemId" to itemId)
+  }
+}

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;;;;;mBAwD2nkC,CAAC;gBAAkB,CAAC;;;;;;;4DAD7qkC,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;;;;;mBAwDw7qC,CAAC;gBAAkB,CAAC;;;;;;;4DAD1+qC,CAAC"}

package/build/ExpoArcgis.types.d.ts

@@ -466,6 +466,11 @@ export type SceneViewHandle = {
     }): Promise<PopupResult[]>;
     /** Retries loading the scene after a failure (e.g. a network outage). Re-fires `onSceneLoaded`/`onSceneLoadError`. */
     retryLoad(): Promise<void>;
+    /**
+     * The terrain elevation (in meters) on the scene's base surface at a geographic point, or `null`
+     * if no surface/elevation is available there.
+     */
+    getElevation(point: Point): Promise<number | null>;
 };
 /** Imperative query handle exposed by `<FeatureLayer>` via `ref`. */
 /** An editing template published with a feature table. Mirrors `FeatureTemplate`. */
@@ -500,6 +505,46 @@ export type AttachmentInfo = {
     /** Size in bytes. */
     size: number;
 };
+/**
+ * One valid contingent value entry, discriminated by `type`:
+ * - `"coded"` — a specific coded-value domain entry is valid; `codedValue.code` is the domain code.
+ * - `"range"` — any numeric value in `[min, max]` is valid.
+ * - `"null"`  — a null / empty value is explicitly allowed for this field.
+ * - `"any"`   — any value is allowed (corresponds to `ContingentAnyValue`).
+ *
+ * `fieldGroupName` identifies which contingent-values field group this constraint belongs to,
+ * allowing callers to match constraints to the group they were defined under.
+ */
+export type ContingentValueEntry = {
+    type: 'coded';
+    fieldGroupName: string;
+    codedValue: {
+        name: string;
+        code: unknown;
+    };
+} | {
+    type: 'range';
+    fieldGroupName: string;
+    min: unknown;
+    max: unknown;
+} | {
+    type: 'null';
+    fieldGroupName: string;
+} | {
+    type: 'any';
+    fieldGroupName: string;
+};
+/**
+ * Result of `FeatureLayerHandle.getContingentValues` — the field name that was queried plus
+ * all valid contingent values for that field given the feature's current attribute state.
+ * An empty `contingentValues` array means no constraints are defined (all values are valid).
+ */
+export type ContingentValuesResult = {
+    /** The field name that was queried. */
+    fieldName: string;
+    /** The valid contingent values, organised across all field groups that reference this field. */
+    contingentValues: ContingentValueEntry[];
+};
 export type FeatureLayerHandle = {
     /** Returns the features matching `query` (all features when omitted). */
     queryFeatures(query?: QueryParameters): Promise<Feature[]>;
@@ -535,6 +580,24 @@ export type FeatureLayerHandle = {
      * ```
      */
     addFeatureWithTemplate(templateName: string, attributes?: Record<string, unknown>, geometry?: Geometry, apply?: boolean): Promise<number | null>;
+    /**
+     * Creates a feature from the named feature subtype (sets the subtype field and inherits the
+     * subtype's default attribute values), then optionally overrides `attributes` on top and sets
+     * `geometry`. By default pushes the edit to the service and resolves to the new object id;
+     * pass `apply: false` to make a local-only edit. Rejects if no subtype with that name exists.
+     * Requires an ArcGIS feature table (service or mobile geodatabase) — rejects for shapefiles
+     * and WFS tables, which do not expose feature subtypes.
+     *
+     * @example
+     * ```ts
+     * const id = await layer.current.addFeatureWithSubtype(
+     *   'Arterial',
+     *   { ROADNAME: 'Main St' },
+     *   { type: 'point', x: -117.19, y: 34.05 }
+     * );
+     * ```
+     */
+    addFeatureWithSubtype(subtypeName: string, attributes?: Record<string, unknown>, geometry?: Geometry, apply?: boolean): Promise<number | null>;
     /** Updates the feature with `objectId`. Pass `apply: false` for a local-only edit. */
     updateFeature(objectId: number, changes: {
         attributes?: Record<string, unknown>;
@@ -577,6 +640,22 @@ export type FeatureLayerHandle = {
      * feature layer. The same handle is returned on repeat calls.
      */
     getServiceGeodatabase(): Promise<ServiceGeodatabaseHandle>;
+    /**
+     * Returns the valid contingent values for `fieldName` on the feature with `objectId`, given
+     * the feature's current attribute state. Contingent values constrain which attribute values
+     * are valid based on the values of other fields (e.g. "species" options depend on "habitat").
+     *
+     * Requires an ArcGIS feature table (service or mobile geodatabase) — rejects for shapefiles
+     * and WFS tables. Resolves with an empty `contingentValues` list when no constraints apply.
+     *
+     * @example
+     * ```ts
+     * const result = await layer.current.getContingentValues(42, 'species');
+     * // result.contingentValues[0] → { type: 'coded', fieldGroupName: 'HabitatGroup',
+     * //                                 codedValue: { name: 'Oak', code: 1 } }
+     * ```
+     */
+    getContingentValues(objectId: number, fieldName: string): Promise<ContingentValuesResult>;
 };
 /** Branch-version access level. */
 export type VersionAccess = 'public' | 'protected' | 'private';
@@ -955,6 +1034,31 @@ export type Envelope = {
     /** Coordinate system WKID. Defaults to `4326` (WGS84). */
     spatialReference?: SpatialReference;
 };
+/** Props for the `<ImageOverlay>` component — a georeferenced image displayed on a `<MapView>`. */
+export type ImageOverlayProps = {
+    /** Local image file path to display (e.g. a downloaded or bundled PNG/JPEG). */
+    imagePath: string;
+    /** The geographic extent (envelope) the image is stretched to fill. */
+    extent: Envelope;
+    /** Overlay opacity, 0–1. Defaults to `1`. */
+    opacity?: number;
+};
+/** A node in a KML document tree, returned by `KmlLayerHandle.getNodes()`. */
+export type KmlNodeInfo = {
+    /** Node display name. */
+    name: string;
+    /** Whether the node is currently visible. */
+    visible: boolean;
+    /** Node class name (e.g. `KMLDocument` / `KMLFolder` / `KMLPlacemark` / `KMLNetworkLink` / `KMLTour`). */
+    type: string;
+    /** Child nodes, present for container nodes (documents / folders). */
+    children?: KmlNodeInfo[];
+};
+/** Imperative handle exposed by `<KmlLayer>` via `ref`. */
+export type KmlLayerHandle = {
+    /** Loads the KML and returns its node tree (recursing into container nodes). */
+    getNodes(): Promise<KmlNodeInfo[]>;
+};
 /**
  * A geometry value. The `type` discriminator mirrors the ArcGIS web API
  * (`"point"` / `"multipoint"` / `"polyline"` / `"polygon"` / `"envelope"`) and
@@ -1507,6 +1611,55 @@ export type UtilityNetworkHandle = {
     /** Returns the associations of a feature queried from `tableName`. */
     associations(tableName: string, whereClause: string): Promise<UtilityAssociationSummary>;
 };
+/** Parameters for `portal.findItems`. */
+export type PortalQuery = {
+    /**
+     * ArcGIS portal search query string (e.g. `'type:"Web Map" owner:esri'`).
+     * Forwarded directly to `PortalQueryParameters(query:limit:)` on both platforms.
+     */
+    query: string;
+    /** Maximum number of items to return (default 10). */
+    max?: number;
+    /** Portal URL (default `https://www.arcgis.com`). */
+    portalUrl?: string;
+};
+/** One portal item returned by `portal.findItems`. */
+export type PortalItemInfo = {
+    /** Portal item id (pass to `<Map portalItem={{ itemId }}>` to display the web map). */
+    id: string;
+    /** Human-readable title. */
+    title: string;
+    /**
+     * Human-readable type string (e.g. `"Web Map"`, `"Feature Service"`).
+     * Maps to `PortalItem.typeName` on both platforms.
+     */
+    type: string;
+    /** Short description / abstract. */
+    snippet: string;
+    /** Portal username of the item owner. */
+    owner: string;
+    /**
+     * Absolute HTTPS URL of the item's thumbnail, or `null` when none is available.
+     * Constructed as `<portalUrl>/sharing/rest/content/items/<id>/info/thumbnail`.
+     * Load it in an `<Image>` component; no auth is required for public items.
+     */
+    thumbnailUrl: string | null;
+};
+/** Parameters for `portal.fetchBasemaps`. */
+export type BasemapQuery = {
+    /** Portal URL (default `https://www.arcgis.com`). */
+    portalUrl?: string;
+};
+/** One basemap returned by `portal.fetchBasemaps`. */
+export type BasemapInfo = {
+    /** Human-readable basemap name (e.g. `"World Topographic Map"`). */
+    name: string;
+    /**
+     * Portal item id of the underlying basemap item, or `null` when the basemap has no item.
+     * Pass to `<Map portalItem={{ itemId }}>` to use it as the map's basemap.
+     */
+    itemId: string | null;
+};
 /** Result of an offline-map download. `path` is the local mobile map package directory. */
 export type OfflineMapResult = {
     /** Local filesystem path of the downloaded mobile map package (pass to `<Map mobileMapPackagePath>`). */
@@ -1753,17 +1906,21 @@ export type PictureMarkerSymbolLayerSpec = {
 /**
  * One vector-marker symbol layer within a `MultilayerPointSymbolType`.
  * Mirrors the native `VectorMarkerSymbolLayer` (a shape drawn from a geometry with fill/stroke,
- * requiring no image). The geometry is defined by a `polygon` (for a filled shape) or a
- * `polyline` (for a stroked shape); polygon is the common case for icons.
+ * requiring no image).
  *
- * Internally the codec builds a `VectorMarkerSymbolElement(geometry, MultilayerPolygonSymbol)`
- * and wraps it in a `VectorMarkerSymbolLayer`.
+ * Supported `geometry` types and how they are symbolised:
+ * - `polygon` — `MultilayerPolygonSymbol([SolidFillSymbolLayer, SolidStrokeSymbolLayer?])`;
+ *   `fillColor` is the fill, `outlineColor`/`outlineWidth` add an optional stroke.
+ * - `polyline` — `MultilayerPolylineSymbol([SolidStrokeSymbolLayer])`; `fillColor` is used as the
+ *   stroke color (falls back to `outlineColor`, then red), `outlineWidth` sets the stroke width.
+ * - `multipoint` — `MultilayerPointSymbol([SolidFillSymbolLayer, SolidStrokeSymbolLayer?])`;
+ *   same color/width props as `polygon`.
  *
- * NOTE: `polyline` and `multipoint` element geometries are DEFERRED — only `polygon` is
- * currently supported. Supplying a non-polygon `geometry` type results in the layer being
- * skipped gracefully.
+ * Any other `geometry` type is silently skipped (the layer is omitted from the symbol).
+ * Geometries use a local coordinate space (not geographic) — use small integer-scale coordinates
+ * (e.g. `x` / `y` in the range `[-1, 1]`).
  *
- * @example
+ * @example — filled triangle (polygon)
  * ```ts
  * { type: 'multilayer-point', symbolLayers: [
  *   { type: 'vector-marker', size: 24,
@@ -1777,9 +1934,10 @@ export type PictureMarkerSymbolLayerSpec = {
 export type VectorMarkerSymbolLayerSpec = {
     type: 'vector-marker';
     /**
-     * The geometry that defines the marker shape. Only `polygon` is supported; other geometry
-     * types are ignored. The polygon is defined in a local coordinate space (not geographic) —
-     * use small integer-scale coordinates (e.g. `x` / `y` in the range `[-1, 1]`).
+     * The geometry that defines the marker shape. Supported types: `polygon`, `polyline`,
+     * `multipoint`. Unsupported types are silently skipped. The geometry is defined in a local
+     * coordinate space (not geographic) — use small integer-scale coordinates
+     * (e.g. `x` / `y` in the range `[-1, 1]`).
      */
     geometry: Geometry;
     /** Overall size of the marker, in points. Scales the geometry uniformly. Defaults to 12. */