diff --git a/client/src/main/scala/ch/wsl/box/client/geo/BoxMapProjections.scala b/client/src/main/scala/ch/wsl/box/client/geo/BoxMapProjections.scala
index 77b9e73a..f07b2d0c 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/BoxMapProjections.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/BoxMapProjections.scala
@@ -6,10 +6,9 @@ import ch.wsl.box.client.services.BrowserConsole
 import ch.wsl.box.model.shared.GeoJson.Coordinates
 import ch.wsl.box.model.shared.geo.{Box2d, MapProjection}
 import scribe.Logging
-import ch.wsl.typings.ol.anon.FnCall
 import ch.wsl.typings.ol.extentMod.Extent
 import ch.wsl.typings.ol.geomMod.Geometry
-import ch.wsl.typings.ol.{extentMod, layerBaseTileMod, layerMod, projMod, projProj4Mod, projProjectionMod, sourceMod}
+import ch.wsl.typings.ol.{anon, extentMod, layerBaseTileMod, layerMod, projMod, projProj4Mod, projProjectionMod, sourceMod}
 
 import scala.scalajs.js
 
@@ -32,14 +31,14 @@ class BoxMapProjections(_projections:Seq[MapProjection],_defaultProjection:Strin
   }
 
 
-  projProj4Mod.register(proj4.asInstanceOf[FnCall])
+  projProj4Mod.register(proj4.asInstanceOf[js.Any with anon.DefaultDatum ])
 
   def convert(from:String,to:String):(Coordinates => Coordinates) = {
     val f = projMod.getTransform(projections(from),projections(to))
 
     { c:Coordinates =>
       val coords = js.Array(c.x, c.y)
-      val out:js.Array[Double] = f(coords,js.undefined,js.undefined)
+      val out:js.Array[Double] = f(coords,js.undefined,js.undefined,js.undefined)
       Coordinates(out(0),out(1))
     }
   }
@@ -107,5 +106,5 @@ object BoxMapConstants {
 //    unit = "m"
   )
 
-  val openStreetMapLayer = new layerMod.Tile(layerBaseTileMod.Options().setSource(new sourceMod.OSM()))
+  val openStreetMapLayer = new layerMod.Tile[sourceMod.OSM](layerBaseTileMod.Options[sourceMod.OSM]().setSource(new sourceMod.OSM()))
 }
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/BoxOlMap.scala b/client/src/main/scala/ch/wsl/box/client/geo/BoxOlMap.scala
index 594ca80c..67fc07cc 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/BoxOlMap.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/BoxOlMap.scala
@@ -1,6 +1,7 @@
 package ch.wsl.box.client.geo
 
 import ch.wsl.box.client.Context.services
+import ch.wsl.box.client.geo.OlTypes.BoxBaseLayer
 import ch.wsl.box.client.services.BrowserConsole
 import io.circe.Json
 import io.udash.{Property, ReadableProperty}
@@ -32,7 +33,7 @@ trait BoxOlMap {
   def loadBase(l: Option[MapParamsLayers])(implicit ex:ExecutionContext): Future[Boolean] = {
     l match {
       case None => {
-        mapActions.setBaseLayer(BoxMapConstants.openStreetMapLayer)
+        mapActions.setBaseLayer(BoxMapConstants.openStreetMapLayer.asInstanceOf[BoxBaseLayer])
         Future.successful(true)
       }
       case Some(layer) => MapUtils.loadWmtsLayer(
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapActions.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapActions.scala
index 0158a64a..18156878 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapActions.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapActions.scala
@@ -1,6 +1,7 @@
 package ch.wsl.box.client.geo
 
 
+import ch.wsl.box.client.geo.OlTypes.{BoxBaseLayer, BoxFeatureType, BoxVectorSourceType}
 import ch.wsl.box.client.services.BrowserConsole
 import ch.wsl.box.client.utils.Debounce
 import ch.wsl.box.model.shared.GeoJson.{CRS, Coordinates, Polygon}
@@ -12,7 +13,8 @@ import io.circe.syntax.EncoderOps
 import scalatags.JsDom.all.s
 import scribe.Logging
 import ch.wsl.typings.ol.mapBrowserEventMod.MapBrowserEvent
-import ch.wsl.typings.ol.{featureMod, formatGeoJSONMod, geomGeometryMod, layerBaseMod, layerBaseVectorMod, layerMod, mapBrowserEventMod, mod, olStrings, sourceMod, sourceVectorMod}
+import ch.wsl.typings.ol.{featureMod, formatGeoJSONMod, geomGeometryMod, layerBaseMod, layerBaseVectorMod, layerMod, layerVectorMod, mapBrowserEventMod, mod, olStrings, sourceMod, sourceVectorMod}
+import org.scalablytyped.runtime.StringDictionary
 
 import scala.collection.mutable
 import scala.concurrent.{ExecutionContext, Promise}
@@ -25,7 +27,7 @@ class MapActions(map: => Option[mod.Map],crs:CRS) extends Logging {
 
   import ch.wsl.box.client.Context._
 
-  def setBaseLayer(baseLayer: layerBaseMod.default) = {
+  def setBaseLayer(baseLayer: BoxBaseLayer) = {
     val promise = Promise[Boolean]()
     logger.info(s"Set base layer $baseLayer with $map")
     BrowserConsole.log(baseLayer)
@@ -69,13 +71,13 @@ class MapActions(map: => Option[mod.Map],crs:CRS) extends Logging {
     })
   }
 
-  private val lookupLayers = mutable.Map[String,(sourceMod.Vector[geomGeometryMod.default],layerMod.Vector[_])]()
+  private val lookupLayers = mutable.Map[String,(BoxVectorSourceType,layerMod.Vector[BoxVectorSourceType,BoxFeatureType])]()
   private def createAndGetSource(layer:MapLookup) = {
     lookupLayers.get(layer.id) match {
       case Some(value) => value
       case None => {
-        val vectorSource = new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options())
-        val featuresLayer = new layerMod.Vector(layerBaseVectorMod.Options()
+        val vectorSource = new sourceMod.Vector[BoxFeatureType](sourceVectorMod.Options())
+        val featuresLayer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
           .setSource(vectorSource)
           .setStyle(MapStyle.vectorStyle(layer.color))
         )
@@ -89,7 +91,7 @@ class MapActions(map: => Option[mod.Map],crs:CRS) extends Logging {
 
     val (vectorSource,featuresLayer)  = createAndGetSource(layer)
 
-    map.get.removeLayer(featuresLayer)
+    map.get.removeLayer(featuresLayer.asInstanceOf[BoxBaseLayer])
     vectorSource.getFeatures().foreach(f => vectorSource.removeFeature(f))
 
     val query = layer.query.getOrElse(JSONQuery.empty).limit(10000).withData(data,services.clientSession.lang()).withExtent(layer.column,calculateExtent(crs))
@@ -97,10 +99,10 @@ class MapActions(map: => Option[mod.Map],crs:CRS) extends Logging {
     services.rest.geoData(layer.kind, services.clientSession.lang(), layer.entity, layer.column, GeoDataRequest(query,Seq()),false).foreach { geoms =>
       val features = geoms.map(MapUtils.boxFeatureToOlFeature)
 
-      vectorSource.addFeatures(features.toJSArray.asInstanceOf[js.Array[ch.wsl.typings.ol.renderFeatureMod.default]])
+      vectorSource.addFeatures(features.toJSArray)
 
 
-      map.get.getLayers().insertAt(1, featuresLayer)
+      map.get.getLayers().insertAt(1, featuresLayer.asInstanceOf[BoxBaseLayer])
 
       map.get.render()
     }
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneDropdown.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneDropdown.scala
index 2f110c06..62e86cc3 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneDropdown.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneDropdown.scala
@@ -10,7 +10,7 @@ import io.udash.bootstrap.utils.BootstrapStyles
 import io.udash._
 import org.scalajs.dom.{Event, Node}
 import scalatags.JsDom.all._
-import ch.wsl.typings.ol.renderFeatureMod
+import ch.wsl.typings.ol.{extentMod, renderFeatureMod}
 import ch.wsl.typings.ol.viewMod.FitOptions
 
 import scala.concurrent.ExecutionContext
@@ -67,7 +67,7 @@ class MapControlStandaloneDropdown(params:MapControlsParams, layerSelector:Modif
         button(ClientConf.style.mapButton)(
           if(geometry.isEmpty) disabled := true else Seq[Modifier](),
           onclick :+= { (e: Event) =>
-            sourceMap(_.getExtent()).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
+            sourceMap(_.getExtent().asInstanceOf[extentMod.Extent]).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
             e.preventDefault()
           }
         )(Icons.search).render,
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneExpanded.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneExpanded.scala
index b60ce550..361edfa3 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneExpanded.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapControlStandaloneExpanded.scala
@@ -1,6 +1,7 @@
 package ch.wsl.box.client.geo
 
 
+import ch.wsl.box.client.geo.OlTypes.BoxFeatureType
 import ch.wsl.box.client.services.{ClientConf, Labels}
 import ch.wsl.box.client.styles.{BootstrapCol, Icons}
 import ch.wsl.box.client.views.components.widget.WidgetUtils
@@ -11,7 +12,7 @@ import io.udash.bootstrap.utils.BootstrapStyles
 import io.udash._
 import org.scalajs.dom.{Event, Node}
 import scalatags.JsDom.all._
-import ch.wsl.typings.ol.{featureMod, geomGeometryMod, geomMod, renderFeatureMod}
+import ch.wsl.typings.ol.{extentMod, featureMod, geomGeometryMod, geomMod, renderFeatureMod}
 import ch.wsl.typings.ol.viewMod.FitOptions
 import io.udash.bootstrap.tooltip.Tooltip
 import org.scalajs.dom
@@ -44,7 +45,7 @@ class MapControlStandaloneExpanded(params:MapControlsParams, title:String, selec
 
     x.combine(y){ case (x,y) => MapUtils.parseCoordinates(params.projections,s"$x, $y")}.listen {
       case Some(point) => {
-        val feature = new featureMod.default[geomGeometryMod.default](new geomMod.Point(point)).asInstanceOf[ch.wsl.typings.ol.renderFeatureMod.default]
+        val feature = new BoxFeatureType(new geomMod.Point(point))
         sourceMap(_.clear())
         sourceMap(_.addFeature(feature))
       }
@@ -118,7 +119,7 @@ class MapControlStandaloneExpanded(params:MapControlsParams, title:String, selec
         button(ClientConf.style.mapButton)(
           if(geometry.isEmpty) disabled := true else Seq[Modifier](),
           onclick :+= { (e: Event) =>
-            sourceMap(_.getExtent()).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
+            sourceMap(_.getExtent().asInstanceOf[extentMod.Extent]).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
             e.preventDefault()
           }
         )(Icons.search).render,
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapControls.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapControls.scala
index 6ddc41f8..7d21cf72 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapControls.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapControls.scala
@@ -28,13 +28,15 @@ import scalatags.JsDom.all._
 import scribe.Logging
 import ch.wsl.typings.ol.interactionSelectMod.SelectEvent
 import ch.wsl.typings.ol.mod.{MapBrowserEvent, Overlay}
-import ch.wsl.typings.ol.{eventsEventMod, featureMod, formatGeoJSONMod, geomGeometryMod, geomMod, interactionDrawMod, interactionModifyMod, interactionSelectMod, interactionSnapMod, interactionTranslateMod, layerMod, mod, objectMod, olStrings, overlayMod, projMod, renderFeatureMod, sourceMod, sourceVectorEventTypeMod}
+import ch.wsl.typings.ol.{eventsEventMod, featureMod, formatGeoJSONMod, geomGeometryMod, geomMod, interactionDrawMod, interactionModifyMod, interactionSelectMod, interactionSnapMod, interactionTranslateMod, layerMod, mod, objectMod, olStrings, overlayMod, projMod, renderFeatureMod, sourceMod, sourceVectorEventTypeMod, sourceVectorMod}
 
 import java.util.UUID
 import scala.concurrent.{ExecutionContext, Future}
 import scala.scalajs.js
 import scala.scalajs.js.{URIUtils, |}
 import scala.util.Try
+import OlTypes._
+import org.scalablytyped.runtime.StringDictionary
 
 
 object Control {
@@ -60,7 +62,7 @@ object Control {
 
 case class BoxLayer(
                       uuid:UUID,
-                     olLayer: layerMod.Vector[_],
+                     olLayer: layerMod.Vector[BoxVectorSourceType,BoxFeatureType],
                      features:MapParamsFeatures
                    )
 
@@ -78,13 +80,13 @@ case class MapControlsParams(
                             ) {
 
 
-  def layerSource: ReadableProperty[Option[layerMod.Vector[_]]] = layer.transform(_.map(_.olLayer))
-  def vectorSource: ReadableProperty[Option[sourceMod.Vector[geomGeometryMod.default]]] = layerSource.transform(_.map(toVectorSource))
-  def sourceMap[T](f:sourceMod.Vector[geomGeometryMod.default] => T):Option[T] = vectorSource.get.map(f)
+  def layerSource: ReadableProperty[Option[layerMod.Vector[BoxVectorSourceType,BoxFeatureType]]] = layer.transform(_.map(_.olLayer))
+  def vectorSource: ReadableProperty[Option[BoxVectorSourceType]] = layerSource.transform(_.map(toVectorSource))
+  def sourceMap[T](f:BoxVectorSourceType => T):Option[T] = vectorSource.get.map(f)
 }
 
 object  MapControlsParams{
-  def toVectorSource(l:layerMod.Vector[_]) = l.getSource().asInstanceOf[sourceMod.Vector[geomGeometryMod.default]]
+  def toVectorSource(l:layerMod.Vector[BoxVectorSourceType,BoxFeatureType]) = l.getSource().asInstanceOf[BoxVectorSourceType]
 }
 
 
@@ -110,7 +112,7 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
   protected val insertCoordinateField = Property("")
   protected val insertCoordinateHandler = ((e: Event) => {
     MapUtils.parseCoordinates(projections,insertCoordinateField.get).foreach { p =>
-      val feature = new featureMod.default[geomGeometryMod.default](new geomMod.Point(p)).asInstanceOf[ch.wsl.typings.ol.renderFeatureMod.default]
+      val feature = new BoxFeatureType(new geomMod.Point(p))
       sourceMap(_.addFeature(feature))
     }
     e.preventDefault()
@@ -167,7 +169,7 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
         }
 
         toInsert.foreach { f =>
-          val geom = new formatGeoJSONMod.default().readFeature(convertJsonToJs(f.asJson).asInstanceOf[js.Object]).asInstanceOf[ch.wsl.typings.ol.renderFeatureMod.default]
+          val geom = new formatGeoJSONMod.default().readFeature(convertJsonToJs(f.asJson).asInstanceOf[js.Object]).asInstanceOf[BoxFeatureType]
           sourceMap(_.addFeature(geom))
         }
 
@@ -178,9 +180,13 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
 
   }
 
-  def findFeature(g: Geometry): Option[featureMod.default[geomGeometryMod.default]] = {
+  def findFeature(g: Geometry): Option[BoxFeatureType] = {
     if (vectorSource != null) {
-      val geoJson = new formatGeoJSONMod.default().writeFeaturesObject(sourceMap(_.getFeatures()).getOrElse(js.Array()))
+
+      val fut: js.Array[BoxFeatureType] = sourceMap(_.getFeatures()).getOrElse(js.Array())
+
+
+      val geoJson = new formatGeoJSONMod.default().writeFeaturesObject(fut.map(_.asInstanceOf[renderFeatureMod.default]))
       convertJsToJson(geoJson.asInstanceOf[js.Any]).flatMap(FeatureCollection.decode).toOption.flatMap { collection =>
 
         val geometries = collection.features.map(_.geometry)
@@ -188,16 +194,16 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
         geometries.find(_.toSingle.contains(g)).flatMap { contanierFeature =>
 
           sourceMap(_.getFeatures().toSeq).toList.flatten.find { f =>
-            val coords = Try(f.getFlatCoordinates()).toOption
+            val coords = MapUtils.getCoordinates(f)
             coords.exists(c => contanierFeature.equalsToFlattenCoords(c.toSeq))
           }
-        }.map(f => renderFeatureMod.toFeature(f))
+        }
       }
     } else None
   }
 
 
-  private var selected: Option[featureMod.default[geomGeometryMod.default]] = None
+  private var selected: Option[BoxFeatureType] = None
 
   def highlight(g: Geometry): Unit = {
     selected.foreach(_.setStyle(MapStyle.vectorStyle()))
@@ -364,7 +370,7 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
     drawHole
   )
 
-  private var oldVectorSource:Option[sourceMod.Vector[geomGeometryMod.default]] = None
+  private var oldVectorSource:Option[BoxVectorSourceType] = None
 
   val changedFeatures: js.Function1[eventsEventMod.BaseEvent,Unit] = (e) => {
 
@@ -452,16 +458,17 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
     )
     //drawPolygon.on_change(olStrings.change,e => changedFeatures())
 
-    snap = new interactionSnapMod.default(interactionSnapMod.Options().setSource(vs))
+    snap = new interactionSnapMod.default(interactionSnapMod.Options().setSource(vs.asInstanceOf[sourceVectorMod.default[renderFeatureMod.default]]))
 
-    def lsFixTypes = ls.olLayer.asInstanceOf[
+
+
+    val layers = js.Array(ls.olLayer).asInstanceOf[js.Array[
       ch.wsl.typings.ol.layerLayerMod.default[
         ch.wsl.typings.ol.sourceSourceMod.default,
-        ch.wsl.typings.ol.layerLayerMod.default[Any, /* ol.ol/layer/Layer.default<any> */ Any]
+        ch.wsl.typings.ol.layerLayerMod.default[Any, /* ol.ol/layer/Layer.default<any> */ Any, StringDictionary[Any]],
+        StringDictionary[Any]
       ]
-    ]
-
-    val layers = js.Array(lsFixTypes)
+    ]]
 
     drag = new interactionTranslateMod.default(interactionTranslateMod.Options().setLayers(layers))
 
@@ -469,7 +476,7 @@ abstract class MapControls(params:MapControlsParams)(implicit ec:ExecutionContex
 
     delete.asInstanceOf[js.Dynamic].on(olStrings.select, (e: objectMod.ObjectEvent | SelectEvent | eventsEventMod.default) => {
       if (window.confirm(Labels.form.removeMap)) {
-        e.asInstanceOf[SelectEvent].selected.foreach(x => sourceMap(_.removeFeature(x)))
+        e.asInstanceOf[SelectEvent].selected.foreach(x => sourceMap(_.removeFeature(x.asInstanceOf[BoxFeatureType])))
         changedFeatures(e.asInstanceOf[eventsEventMod.BaseEvent])
       } else {
         delete.getFeatures().clear()
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapControlsIcons.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapControlsIcons.scala
index 94b35970..8021e914 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapControlsIcons.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapControlsIcons.scala
@@ -10,7 +10,7 @@ import io.udash.bootstrap.utils.BootstrapStyles
 import io.udash._
 import org.scalajs.dom.{Event, Node}
 import scalatags.JsDom.all._
-import ch.wsl.typings.ol.renderFeatureMod
+import ch.wsl.typings.ol.{extentMod, renderFeatureMod}
 import ch.wsl.typings.ol.viewMod.FitOptions
 import org.scalajs.dom
 import org.scalajs.dom.html.Input
@@ -71,7 +71,7 @@ class MapControlsIcons(params:MapControlsParams)(implicit ec:ExecutionContext) e
         if (geometry.nonEmpty) controlButton(Icons.trash, SharedLabels.map.delete, Control.DELETE,nested) else frag(),
         if (geometry.nonEmpty) button(ClientConf.style.mapButton)(
           onclick :+= { (e: Event) =>
-            sourceMap(_.getExtent()).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
+            sourceMap(_.getExtent().asInstanceOf[extentMod.Extent]).foreach(e => map.getView().fit(e, FitOptions().setPaddingVarargs(10, 10, 10, 10).setMinResolution(0.5)))
             e.preventDefault()
           }
         )(Icons.search).render else frag(),
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapGeolocation.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapGeolocation.scala
index af5ca5ac..6d803f1a 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapGeolocation.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapGeolocation.scala
@@ -1,9 +1,10 @@
 package ch.wsl.box.client.geo
 
+import ch.wsl.box.client.geo.OlTypes.{BoxBaseLayer, BoxFeatureType, BoxProperyType, BoxVectorSourceType}
 import ch.wsl.box.client.styles.Icons
 import ch.wsl.typings.ol
 import ch.wsl.typings.ol.geomMod.Point
-import ch.wsl.typings.ol.{controlControlMod, controlMod, geolocationMod, geomGeometryMod, geomMod, imageMod, layerBaseVectorMod, layerMod, mod, renderFeatureMod, sourceMod, sourceVectorMod, styleMod}
+import ch.wsl.typings.ol.{controlControlMod, controlMod, geolocationMod, geomGeometryMod, geomMod, imageMod, layerBaseVectorMod, layerMod, layerVectorMod, mod, renderFeatureMod, sourceMod, sourceVectorMod, styleMod}
 import org.scalajs.dom.{Event, HTMLInputElement, PositionOptions}
 import scalatags.JsDom.all.{`class`, `type`, div, input, onchange, style}
 
@@ -18,13 +19,13 @@ class MapGeolocation(map:mod.Map) {
       .setProjection(map.getView().getProjection())
   )
 
-  val accuracyFeature = new mod.Feature[geomMod.Geometry]()
-  val positionFeature = new mod.Feature[Point]()
+  val accuracyFeature = new BoxFeatureType()
+  val positionFeature = new BoxFeatureType()
 
-  val gpsVectorSource = new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options())
-  gpsVectorSource.addFeature(accuracyFeature.asInstanceOf[renderFeatureMod.default])
-  gpsVectorSource.addFeature(positionFeature.asInstanceOf[renderFeatureMod.default])
-  val gpsFeaturesLayer = new layerMod.Vector(layerBaseVectorMod.Options()
+  val gpsVectorSource = new BoxVectorSourceType(sourceVectorMod.Options[BoxFeatureType]())
+  gpsVectorSource.addFeature(accuracyFeature)
+  gpsVectorSource.addFeature(positionFeature)
+  val gpsFeaturesLayer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
     .setSource(gpsVectorSource)
   )
 
@@ -56,10 +57,10 @@ class MapGeolocation(map:mod.Map) {
     onchange :+= {(e:Event) =>
       if(e.target.asInstanceOf[HTMLInputElement].checked) {
         geolocation.setTracking(true)
-        map.addLayer(gpsFeaturesLayer)
+        map.addLayer(gpsFeaturesLayer.asInstanceOf[BoxBaseLayer])
       } else {
         geolocation.setTracking(false)
-        map.removeLayer(gpsFeaturesLayer)
+        map.removeLayer(gpsFeaturesLayer.asInstanceOf[BoxBaseLayer])
       }
 
 
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapStyle.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapStyle.scala
index ac2d0bee..03fbf461 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapStyle.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapStyle.scala
@@ -27,7 +27,7 @@ object MapStyle {
     )
   }
 
-  def vectorStyle(color:String = "rgb(237, 28, 36)"): js.Array[ch.wsl.typings.ol.styleStyleMod.Style] = js.Array(
+  def vectorStyle(color:String = "rgb(237, 28, 36)"):js.Array[ch.wsl.typings.ol.styleStyleMod.Style]  = js.Array(
     simpleStyle(color),
     new styleMod.Style(styleStyleMod.Options()
       .setImage(
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/MapUtils.scala b/client/src/main/scala/ch/wsl/box/client/geo/MapUtils.scala
index ec1e19a1..08da2dc9 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/MapUtils.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/MapUtils.scala
@@ -1,6 +1,7 @@
 package ch.wsl.box.client.geo
 
 import ch.wsl.box.client.Context.services
+import ch.wsl.box.client.geo.OlTypes.{BoxBaseLayer, BoxFeatureType, BoxProperyType, BoxVectorSourceType}
 import ch.wsl.box.client.services.BrowserConsole
 import ch.wsl.box.model.shared.{GeoJson, JSONID}
 import ch.wsl.box.model.shared.GeoJson._
@@ -13,17 +14,18 @@ import org.scalajs.dom
 import scalatags.JsDom.all.s
 import scribe.Logging
 import ch.wsl.typings.ol.coordinateMod.Coordinate
+import ch.wsl.typings.ol.geomSimpleGeometryMod.SimpleGeometry
 import ch.wsl.typings.ol.layerLayerMod.Layer
 import ch.wsl.typings.ol.layerTileMod.TileLayer
 import ch.wsl.typings.ol.mapBrowserEventMod.MapBrowserEvent
 import ch.wsl.typings.ol.renderEventMod.RenderEvent
 import ch.wsl.typings.ol.styleCircleMod.CircleStyle
 import ch.wsl.typings.ol.styleMod.{Circle, Stroke, Style}
-import ch.wsl.typings.ol.{featureMod, formatGeoJSONMod, formatMod, geomGeometryMod, layerBaseMod, layerBaseTileMod, layerMod, mod, observableMod, projMod, sourceMod, sourceWmtsMod, styleCircleMod, styleFillMod, styleMod, styleStrokeMod, styleStyleMod}
+import ch.wsl.typings.ol.{featureMod, formatGeoJSONMod, formatMod, geomGeometryMod, geomMod, layerBaseMod, layerBaseTileMod, layerMod, mod, observableMod, projMod, sourceMod, sourceWmtsMod, styleCircleMod, styleFillMod, styleMod, styleStrokeMod, styleStyleMod}
 import org.scalajs.dom.Event
 
 import java.util.{Date, UUID}
-import scala.concurrent.Promise
+import scala.concurrent.{Future, Promise}
 import scala.scalajs.js
 import scala.scalajs.js.|._
 import scala.util.Try
@@ -32,9 +34,9 @@ object MapUtils extends Logging {
 
   val BOX_LAYER_ID = "box_layer_id"
 
-  def loadWmtsLayer(id:UUID, capabilitiesUrl: String, layer: String, time: Option[String],zIndex: Int = 0) = {
+  def loadWmtsLayer(id:UUID, capabilitiesUrl: String, layer: String, time: Option[String],zIndex: Int = 0): Future[BoxBaseLayer] = {
 
-    val result = Promise[layerMod.Tile[_]]()
+    val result = Promise[BoxBaseLayer]()
 
     logger.info(s"Loading WMTS layer $layer")
 
@@ -56,11 +58,11 @@ object MapUtils extends Logging {
           wmtsOptions .setDimensions(js.Dictionary("Time" -> t))
         }
 
-        val wmts = new layerMod.Tile(layerBaseTileMod.Options()
+        val wmts = new layerMod.Tile[sourceMod.WMTS](layerBaseTileMod.Options[sourceMod.WMTS]()
           .setSource(new sourceMod.WMTS(wmtsOptions))
           .setZIndex(zIndex)
           .setProperties(StringDictionary((BOX_LAYER_ID, id.toString)))
-        )
+        ).asInstanceOf[BoxBaseLayer]
         result.success(wmts)
       }
     }
@@ -122,9 +124,9 @@ object MapUtils extends Logging {
     GeoJson.Feature(GeoJson.Point(Coordinates(c(0), c(1)), crs))
   }
 
-  def getFeatures(map: mod.Map,e: MapBrowserEvent[_]): js.Array[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default]] = {
+  def getFeatures(map: mod.Map,e: MapBrowserEvent[_]): js.Array[BoxFeatureType] = {
     map.getFeaturesAtPixel(e.pixel).flatMap {
-      case x: ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default] => Some(x)
+      case x: BoxFeatureType => Some(x)
       case _ => None
     }
   }
@@ -192,8 +194,8 @@ object MapUtils extends Logging {
 
 
 
-  def vectorSourceGeoms(vectorSource:sourceMod.Vector[_],defaultProjection:String): Option[FeatureCollection] = {
-    val geoJson = new formatGeoJSONMod.default().writeFeaturesObject(vectorSource.getFeatures())
+  def vectorSourceGeoms(vectorSource:BoxVectorSourceType,defaultProjection:String): Option[FeatureCollection] = {
+    val geoJson = new formatGeoJSONMod.default().writeFeaturesObject(vectorSource.getFeatures().map(_.asInstanceOf[ch.wsl.typings.ol.renderFeatureMod.default]))
     for{
       json <- convertJsToJson(geoJson.asInstanceOf[js.Any]).toOption
       // Maunually attach CRS since the standard in not well defined
@@ -256,9 +258,9 @@ object MapUtils extends Logging {
     result
   }
 
-  def boxFeatureToOlFeature(box:Feature): featureMod.default[geomGeometryMod.default] = {
+  def boxFeatureToOlFeature(box:Feature): BoxFeatureType = {
     import io.circe.generic.auto._
-    val ol = new formatGeoJSONMod.default().readFeature(convertJsonToJs(box.asJson).asInstanceOf[js.Object]).asInstanceOf[featureMod.default[geomGeometryMod.default]]
+    val ol = new formatGeoJSONMod.default().readFeature(convertJsonToJs(box.asJson).asInstanceOf[js.Object]).asInstanceOf[BoxFeatureType]
     box.properties.flatMap(_.apply("jsonid").flatMap(_.as[JSONID].toOption)).map(_.asString).foreach{ id =>
       if(id.nonEmpty) {
         ol.setId(id)
@@ -275,7 +277,7 @@ object MapUtils extends Logging {
     ch.wsl.typings.ol.eventsMod.unlistenByKey(listenerKey)
   }
 
-  def flash(feature: ch.wsl.typings.ol.featureMod.Feature[_], map: ch.wsl.typings.ol.mod.Map,layer:ch.wsl.typings.ol.layerMod.Vector[_]): Unit = {
+  def flash(feature: ch.wsl.typings.ol.featureMod.Feature[_,_], map: ch.wsl.typings.ol.mod.Map,layer:ch.wsl.typings.ol.layerMod.Vector[_,_]): Unit = {
     val period = 1000
     val start = new Date().getTime
 
@@ -335,18 +337,31 @@ object MapUtils extends Logging {
 
   }
 
+  def getCoordinates(f:BoxFeatureType):Option[Coordinate] = {
+    f.getGeometry().toOption.flatMap {
+      case t:geomMod.Point => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.MultiPoint => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.Circle => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.LineString => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.MultiLineString => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.Polygon => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case t:geomMod.MultiPolygon => Some(t.getCoordinates().asInstanceOf[Coordinate])
+      case _ => None
+    }
+  }
+
 
   implicit class EnanchedMap(map: mod.Map) {
 
 
 
-    def layerOf(id: UUID): Option[layerBaseMod.default] = map.getLayers().getArray().find(_.getProperties().get(MapUtils.BOX_LAYER_ID).contains(id.toString))
+    def layerOf(id: UUID): Option[layerBaseMod.default[BoxProperyType]] = map.getLayers().getArray().find(_.getProperties().asInstanceOf[Map[String,String]].get(MapUtils.BOX_LAYER_ID).contains(id.toString))
 
-    def layerOf(db: DbVector): Option[layerMod.Vector[_]] = layerOf(db.id).map(_.asInstanceOf[layerMod.Vector[_]])
+    def layerOf(db: DbVector): Option[layerMod.Vector[BoxVectorSourceType,BoxFeatureType]] = layerOf(db.id).map(_.asInstanceOf[layerMod.Vector[BoxVectorSourceType,BoxFeatureType]])
     def layerOf(wmts: WMTS): Option[layerMod.Tile[_]] = layerOf(wmts.id).map(_.asInstanceOf[layerMod.Tile[_]])
 
 
-    def sourceOf(db: DbVector): Option[sourceMod.Vector[_]] = layerOf(db).map(_.getSource().asInstanceOf[sourceMod.Vector[_]])
+    def sourceOf(db: DbVector): Option[BoxVectorSourceType] = layerOf(db).map(_.getSource().asInstanceOf[BoxVectorSourceType])
   }
 
 
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/OlTypes.scala b/client/src/main/scala/ch/wsl/box/client/geo/OlTypes.scala
new file mode 100644
index 00000000..c96d97b8
--- /dev/null
+++ b/client/src/main/scala/ch/wsl/box/client/geo/OlTypes.scala
@@ -0,0 +1,13 @@
+package ch.wsl.box.client.geo
+
+import ch.wsl.typings.ol.layerBaseMod
+import org.scalablytyped.runtime.StringDictionary
+
+object OlTypes {
+
+  type BoxProperyType = org.scalablytyped.runtime.StringDictionary[Any]
+  type BoxBaseLayer = layerBaseMod.default[BoxProperyType]
+
+  type BoxFeatureType = ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default,BoxProperyType]
+  type BoxVectorSourceType = ch.wsl.typings.ol.sourceVectorMod.default[BoxFeatureType]
+}
diff --git a/client/src/main/scala/ch/wsl/box/client/geo/StandaloneMap.scala b/client/src/main/scala/ch/wsl/box/client/geo/StandaloneMap.scala
index c10c1504..6373a2b2 100644
--- a/client/src/main/scala/ch/wsl/box/client/geo/StandaloneMap.scala
+++ b/client/src/main/scala/ch/wsl/box/client/geo/StandaloneMap.scala
@@ -16,7 +16,7 @@ import org.scalablytyped.runtime.StringDictionary
 import org.scalajs.dom.MutationObserver
 import scalatags.JsDom.{StringFrag, _}
 import scalatags.JsDom.all._
-import ch.wsl.typings.ol.{extentMod, featureMod, formatGeoJSONMod, geomGeometryMod, layerBaseMod, layerBaseVectorMod, layerMod, mod, olStrings, sourceMod, sourceVectorMod, viewMod}
+import ch.wsl.typings.ol.{extentMod, featureMod, formatGeoJSONMod, geomGeometryMod, layerBaseMod, layerBaseVectorMod, layerMod, layerVectorMod, mod, olStrings, sourceMod, sourceVectorMod, viewMod}
 import org.scalajs.dom._
 import org.scalajs.dom.html.Div
 import ch.wsl.typings.ol.mapMod.MapOptions
@@ -32,6 +32,7 @@ import scala.util.Try
 import io.udash.css.CssView._
 import scalacss.ScalatagsCss._
 import MapUtils._
+import ch.wsl.box.client.geo.OlTypes.{BoxBaseLayer, BoxFeatureType, BoxProperyType, BoxVectorSourceType}
 import scribe.Logging
 
 abstract class StandaloneMap(_div:Div, metadata:MapMetadata,properties:ReadableProperty[Json],data:Property[Json]) extends Logging {
@@ -206,25 +207,28 @@ abstract class StandaloneMap(_div:Div, metadata:MapMetadata,properties:ReadableP
     }
   }
 
-  private def extentOfLayers(layers:js.Array[layerBaseMod.default]):Option[extentMod.Extent] = { // calculate extent only of nonEmpty layers
-    val layersExtent = layers.flatMap {
-      case v: layerMod.Vector[_] => {
-        val vs = v.getSource().asInstanceOf[sourceMod.Vector[geomGeometryMod.default]]
-        if (vs.getFeatures().isEmpty) None else Some(vs.getExtent())
+  private def extentOfLayers(layers:js.Array[BoxBaseLayer]):Option[extentMod.Extent] = { // calculate extent only of nonEmpty layers
+    val layersExtent = layers.map(_.asInstanceOf[js.Any]).flatMap {
+      case v: layerMod.Vector[BoxVectorSourceType,BoxFeatureType] => {
+        val vs = v.getSource().asInstanceOf[BoxVectorSourceType]
+        if (vs.getFeatures().isEmpty) None else Some(vs.getExtent().asInstanceOf[extentMod.Extent])
       }
       case _ => None
     }
+    layersExtent.tail.foreach{ e =>
+      extentMod.extend(layersExtent.head,e)
+    }
     if (layersExtent.isEmpty) {
       None
     } else {
-      Some(layersExtent.reduce(extentMod.extend))
+      Some(layersExtent.head)
     }
   }
 
   def fit():Box2d = {
     val focusedExtent = Try{
-      val layers = metadata.db.filter(_.autofocus).flatMap(map.layerOf).map(_.asInstanceOf[layerBaseMod.default]).toJSArray
-      extentOfLayers(layers)
+      val layers = metadata.db.filter(_.autofocus).flatMap(map.layerOf).toJSArray
+      extentOfLayers(layers.map(_.asInstanceOf[BoxBaseLayer]))
     }.toOption.flatten
 
     val extent = if (focusedExtent.nonEmpty && !focusedExtent.contains(null)) Some(focusedExtent.get) else {
@@ -238,7 +242,7 @@ abstract class StandaloneMap(_div:Div, metadata:MapMetadata,properties:ReadableP
     Box2d.fromSeq(extent.getOrElse(map.getView().calculateExtent()).toSeq)
   }
 
-  def addLayers(layers:Seq[layerBaseMod.default], replace: Boolean = false, initialState:Option[Boolean] = None) = {
+  def addLayers(layers:Seq[BoxBaseLayer], replace: Boolean = false, initialState:Option[Boolean] = None) = {
     layers.foreach { layer =>
 
       map.getLayers().getArray().find(_.getZIndex() == layer.getZIndex()) match {
@@ -262,7 +266,7 @@ abstract class StandaloneMap(_div:Div, metadata:MapMetadata,properties:ReadableP
   def addFeaturesToLayer(db: DbVector, geoms:GeoData) = {
     map.sourceOf(db).map{s =>
       val features = geoms.map(MapUtils.boxFeatureToOlFeature)
-      s.addFeatures(features.toJSArray.asInstanceOf[js.Array[ch.wsl.typings.ol.renderFeatureMod.default]])
+      s.addFeatures(features.toJSArray)
     }
 
   }
@@ -295,20 +299,20 @@ abstract class StandaloneMap(_div:Div, metadata:MapMetadata,properties:ReadableP
 
 
 
-  def geomsToLayer(vector:DbVector,geoms:GeoData):layerMod.Vector[_] = {
-    val vectorSource = new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options())
+  def geomsToLayer(vector:DbVector,geoms:GeoData):BoxBaseLayer = {
+    val vectorSource = new sourceMod.Vector[BoxFeatureType](sourceVectorMod.Options())
     val features = geoms.map(MapUtils.boxFeatureToOlFeature)
 
-    vectorSource.addFeatures(features.toJSArray.asInstanceOf[js.Array[ch.wsl.typings.ol.renderFeatureMod.default]])
+    vectorSource.addFeatures(features.toJSArray)
 
-    val layer = new layerMod.Vector(layerBaseVectorMod.Options()
+    val layer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
       .setSource(vectorSource)
       .setZIndex(vector.zIndex)
       .setProperties(StringDictionary((MapUtils.BOX_LAYER_ID, vector.id.toString)))
       .setStyle(MapStyle.vectorStyle(vector.color))
     )
 
-    layer
+    layer.asInstanceOf[BoxBaseLayer]
   }
 
 
diff --git a/client/src/main/scala/ch/wsl/box/client/vendors/OlExt.scala b/client/src/main/scala/ch/wsl/box/client/vendors/OlExt.scala
index 601d494f..c9aad649 100644
--- a/client/src/main/scala/ch/wsl/box/client/vendors/OlExt.scala
+++ b/client/src/main/scala/ch/wsl/box/client/vendors/OlExt.scala
@@ -23,13 +23,13 @@ trait DrawHoleOptions extends js.Object {
   var addCondition: js.UndefOr[Condition] = js.native
   var condition: js.UndefOr[Condition] = js.native
   var features: js.UndefOr[
-    ch.wsl.typings.ol.collectionMod.default[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default]]
+    ch.wsl.typings.ol.collectionMod.default[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default,js.Any]]
   ] = js.native
   var filter: js.UndefOr[FilterFunction] = js.native
   var hitTolerance: js.UndefOr[Double] = js.native
   var layers: js.UndefOr[
-    js.Array[ch.wsl.typings.ol.layerLayerMod.default[ch.wsl.typings.ol.sourceSourceMod.default,_]] | (js.Function1[
-      /* p0 */ ch.wsl.typings.ol.layerLayerMod.default[ch.wsl.typings.ol.sourceSourceMod.default,_],
+    js.Array[ch.wsl.typings.ol.layerLayerMod.default[ch.wsl.typings.ol.sourceSourceMod.default,_,_]] | (js.Function1[
+      /* p0 */ ch.wsl.typings.ol.layerLayerMod.default[ch.wsl.typings.ol.sourceSourceMod.default,_,_],
       Boolean
     ])
   ] = js.native
@@ -72,7 +72,7 @@ object DrawHoleOptions{
       def deleteDragVertexDelay: Self = this.set("dragVertexDelay", js.undefined)
       @scala.inline
       def setFeatures(
-                       value: ch.wsl.typings.ol.collectionMod.default[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default]]
+                       value: ch.wsl.typings.ol.collectionMod.default[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default,_]]
                      ): Self = this.set("features", value.asInstanceOf[js.Any])
       @scala.inline
       def deleteFeatures: Self = this.set("features", js.undefined)
@@ -111,7 +111,7 @@ object DrawHoleOptions{
       @scala.inline
       def deleteSnapTolerance: Self = this.set("snapTolerance", js.undefined)
       @scala.inline
-      def setSource(value: ch.wsl.typings.ol.sourceVectorMod.default[ch.wsl.typings.ol.geomGeometryMod.default]): Self = this.set("source", value.asInstanceOf[js.Any])
+      def setSource(value: js.Any): Self = this.set("source", value)
       @scala.inline
       def deleteSource: Self = this.set("source", js.undefined)
       @scala.inline
diff --git a/client/src/main/scala/ch/wsl/box/client/views/components/MapList.scala b/client/src/main/scala/ch/wsl/box/client/views/components/MapList.scala
index e07d61c6..89052864 100644
--- a/client/src/main/scala/ch/wsl/box/client/views/components/MapList.scala
+++ b/client/src/main/scala/ch/wsl/box/client/views/components/MapList.scala
@@ -26,6 +26,7 @@ import ch.wsl.typings.ol.mod.{Feature, MapBrowserEvent, Overlay}
 import ch.wsl.typings.ol.objectMod.ObjectEvent
 import ch.wsl.typings.ol.viewMod.FitOptions
 import ch.wsl.typings.ol.{extentMod, featureMod, formatGeoJSONMod, geomGeometryMod, layerBaseVectorMod, layerMod, mapBrowserEventMod, mod, olStrings, renderFeatureMod, sourceMod, sourceVectorMod, viewMod}
+import ch.wsl.box.client.geo.OlTypes._
 
 import scala.concurrent.duration.DurationInt
 import scala.scalajs.js
@@ -34,6 +35,7 @@ import scalatags.JsDom.all._
 import io.udash._
 import io.udash.bindings.modifiers.Binding.NestedInterceptor
 import io.udash.wrappers.jquery.jQ
+import org.scalablytyped.runtime.StringDictionary
 
 class MapList(_div:Div,metadata:JSONMetadata,geoms:ReadableProperty[GeoTypes.GeoData],edit: String => Unit,extent:Property[Option[Polygon]],extentFilter:Property[Boolean]) extends BoxOlMap {
 
@@ -124,10 +126,10 @@ class MapList(_div:Div,metadata:JSONMetadata,geoms:ReadableProperty[GeoTypes.Geo
 
   val geolocation = new MapGeolocation(map)
 
-  val vectorSource = new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options())
+  val vectorSource = new sourceMod.Vector[BoxFeatureType](sourceVectorMod.Options())
 
   def zoomToFeatures() = {
-    val sourceExtent = vectorSource.getExtent()
+    val sourceExtent = vectorSource.getExtent().asInstanceOf[extentMod.Extent]
     map.getView().fit(sourceExtent,FitOptions().setPadding(js.Array(20.0,20.0,20.0,20.0)))
   }
 
@@ -188,19 +190,19 @@ class MapList(_div:Div,metadata:JSONMetadata,geoms:ReadableProperty[GeoTypes.Geo
 
 
 
-    val featuresLayer = new layerMod.Vector(layerBaseVectorMod.Options()
+    val featuresLayer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
       .setSource(vectorSource)
       .setStyle(style)
     )
 
-    val hoverLayer = new layerMod.Vector(layerBaseVectorMod.Options()
+    val hoverLayer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
       .setStyle(style)
       .setZIndex(100)
-      .setSource(new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options()))
+      .setSource(new sourceMod.Vector[BoxFeatureType](sourceVectorMod.Options[BoxFeatureType]()))
     )
 
-    map.addLayer(featuresLayer)
-    map.addLayer(hoverLayer)
+    map.addLayer(featuresLayer.asInstanceOf[layerBaseMod.default[StringDictionary[Any]]])
+    map.addLayer(hoverLayer.asInstanceOf[layerBaseMod.default[StringDictionary[Any]]])
 
 
     val extentChange = Debounce(250.millis)((_: Unit) => {
@@ -214,15 +216,15 @@ class MapList(_div:Div,metadata:JSONMetadata,geoms:ReadableProperty[GeoTypes.Geo
 
     geoms.listen({ layers =>
       extentChangeListenerActive = false
-      map.removeLayer(featuresLayer)
+      map.removeLayer(featuresLayer.asInstanceOf[layerBaseMod.default[StringDictionary[Any]]])
       vectorSource.getFeatures().foreach(f => vectorSource.removeFeature(f))
 
       layers.foreach { g =>
         val geom = MapUtils.boxFeatureToOlFeature(g)
-        vectorSource.addFeature(geom.asInstanceOf[renderFeatureMod.default])
+        vectorSource.addFeature(geom)
       }
 
-      map.addLayer(featuresLayer)
+      map.addLayer(featuresLayer.asInstanceOf[layerBaseMod.default[StringDictionary[Any]]])
 
       if (extent.get.isEmpty && layers.nonEmpty) {
 
@@ -319,7 +321,7 @@ class MapList(_div:Div,metadata:JSONMetadata,geoms:ReadableProperty[GeoTypes.Geo
 
     services.messages.sub{
       case RowHover(row) => {
-        val f = vectorSource.getFeatureById(row.id.map(_.asString).getOrElse("")).asInstanceOf[Feature[_]]
+        val f = vectorSource.getFeatureById(row.id.map(_.asString).getOrElse("")).asInstanceOf[Feature[_,_]]
         if(f != null) {
             MapUtils.flash(f,map,hoverLayer)
         }
diff --git a/client/src/main/scala/ch/wsl/box/client/views/components/widget/geo/OlMapWidget.scala b/client/src/main/scala/ch/wsl/box/client/views/components/widget/geo/OlMapWidget.scala
index a68b69cf..fef71102 100644
--- a/client/src/main/scala/ch/wsl/box/client/views/components/widget/geo/OlMapWidget.scala
+++ b/client/src/main/scala/ch/wsl/box/client/views/components/widget/geo/OlMapWidget.scala
@@ -44,11 +44,13 @@ import ch.wsl.typings.ol.olStrings.singleclick
 import ch.wsl.box.model.shared.GeoJson.Geometry._
 import ch.wsl.box.model.shared.GeoJson._
 import ch.wsl.typings.ol.extentMod.Extent
+import ch.wsl.typings.ol.featureMod.FeatureLike
 import ch.wsl.typings.ol.formatFeatureMod.ReadOptions
 import io.udash.bindings.modifiers.Binding
 import org.http4s.dom.FetchClientBuilder
 import ch.wsl.typings.ol.mapMod.MapOptions
 import ch.wsl.typings.ol.objectMod.ObjectEvent
+import org.scalablytyped.runtime.StringDictionary
 import org.scalajs.dom.window.setTimeout
 
 import java.util.UUID
@@ -78,6 +80,9 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
   import io.udash.css.CssView._
   import scalacss.ScalatagsCss._
   import scalatags.JsDom.all._
+  import ch.wsl.box.client.geo.OlTypes._
+
+
 
   val _data:Property[Option[Geometry]] = Property(None)
 
@@ -121,7 +126,7 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
 
   lazy val mapActions = new MapActions(map,options.crs)
 
-  var featuresLayer: layerMod.Vector[_] = null
+  var featuresLayer: layerMod.Vector[BoxVectorSourceType,BoxFeatureType] = null
 
 
   var _loaded = false
@@ -131,7 +136,7 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
     if(map.nonEmpty && featuresLayer != null) {
       _loaded = false
       loadBase(baseLayer.get).flatMap { _ =>
-        map.get.addLayer(featuresLayer)
+        map.get.addLayer(featuresLayer.asInstanceOf[BoxBaseLayer])
         map.get.updateSize()
         map.get.renderSync()
         //data.touch()
@@ -180,7 +185,7 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
     promise.future
   }
 
-  var vectorSource: sourceMod.Vector[geomGeometryMod.default] = null
+  var vectorSource: sourceMod.Vector[BoxFeatureType] = null
   var view: viewMod.default = null
 
 
@@ -195,8 +200,8 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
           setTimeout(() => {
             Try {
               if (!geo.isNull) {
-                val geom = new formatGeoJSONMod.default().readFeature(convertJsonToJs(geo).asInstanceOf[js.Object]).asInstanceOf[featureMod.default[geomGeometryMod.default]]
-                vectorSource.addFeature(geom.asInstanceOf[renderFeatureMod.default])
+                val geom = new formatGeoJSONMod.default().readFeature(convertJsonToJs(geo).asInstanceOf[js.Object]).asInstanceOf[featureMod.default[geomGeometryMod.default,StringDictionary[Any]]]
+                vectorSource.addFeature(geom)
                 if (geom.getGeometry().get.getType() != geomGeometryMod.Type.Point) {
                   view.fit(geom.getGeometry().get.getExtent(), FitOptions().setPaddingVarargs(50, 50, 50, 50))
                 } else {
@@ -259,9 +264,9 @@ class OlMapWidget(val id: ReadableProperty[Option[String]], val field: JSONField
 
     _mapDiv = Some(mapDiv)
 
-     vectorSource = new sourceMod.Vector[geomGeometryMod.default](sourceVectorMod.Options())
+     vectorSource = new sourceMod.Vector[BoxFeatureType](sourceVectorMod.Options[ch.wsl.typings.ol.featureMod.default[ch.wsl.typings.ol.geomGeometryMod.default,org.scalablytyped.runtime.StringDictionary[Any]]]())
 
-    featuresLayer = new layerMod.Vector(layerBaseVectorMod.Options()
+    featuresLayer = new layerMod.Vector[BoxVectorSourceType,BoxFeatureType](layerVectorMod.Options[BoxVectorSourceType,BoxFeatureType]()
       .setSource(vectorSource)
       .setStyle(MapStyle.vectorStyle())
     )