diff --git a/requirements.txt b/requirements.txt
index 45ab646..e7f9f28 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -61,4 +61,3 @@ wslink==1.12.4
 yarl>=1
     # via aiohttp
 
-opengeodeweb-microservice==1.*,>=1.0.13rc1
diff --git a/src/opengeodeweb_viewer/object/object_methods.py b/src/opengeodeweb_viewer/object/object_methods.py
index 2cf180d..3ce9ea7 100644
--- a/src/opengeodeweb_viewer/object/object_methods.py
+++ b/src/opengeodeweb_viewer/object/object_methods.py
@@ -13,7 +13,7 @@
 from vtkmodules.vtkCommonDataModel import vtkDataObject, vtkDataSet
 
 # Local application imports
-from opengeodeweb_viewer.vtk_protocol import VtkView, vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkView, VtkPipeline
 
 
 class VtkObjectView(VtkView):
@@ -24,7 +24,7 @@ def registerObject(
         self,
         id: str,
         file_name: str,
-        data: vtkData,
+        data: VtkPipeline,
     ) -> None:
         self.register_object(id, data)
         data.reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
@@ -47,74 +47,69 @@ def registerObject(
             renderer.ResetCamera()
 
     def deregisterObject(self, data_id: str) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
         self.deregister_object(data_id)
 
     def SetVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.SetVisibility(visibility)
 
     def SetOpacity(self, data_id: str, opacity: float) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetOpacity(opacity)
 
     def SetColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOff()
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
 
     def SetEdgesVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             self.SetVisibility(data_id, visibility)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetEdgeVisibility(visibility)
 
     def SetEdgesWidth(self, data_id: str, width: float) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        actor = self.get_vtk_pipeline(data_id).actor
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             actor.GetProperty().SetLineWidth(width)
         else:
             actor.GetProperty().SetEdgeWidth(width)
 
     def SetEdgesColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             self.SetColor(data_id, red, green, blue)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
 
     def SetPointsVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "points":
+        if self.get_viewer_data(data_id).viewer_elements_type == "points":
             self.SetVisibility(data_id, visibility)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetVertexVisibility(visibility)
 
     def SetPointsSize(self, data_id: str, size: float) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetPointSize(size)
 
     def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "points":
+        if self.get_viewer_data(data_id).viewer_elements_type == "points":
             self.SetColor(data_id, red, green, blue)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
 
     def SetBlocksVisibility(
         self, data_id: str, block_ids: list[int], visibility: bool
     ) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         if not isinstance(mapper, vtkCompositePolyDataMapper):
             raise Exception("Mapper is not a vtkCompositePolyDataMapper")
         for block_id in block_ids:
@@ -123,14 +118,14 @@ def SetBlocksVisibility(
     def SetBlocksColor(
         self, data_id: str, block_ids: list[int], red: int, green: int, blue: int
     ) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         if not isinstance(mapper, vtkCompositePolyDataMapper):
             raise Exception("Mapper is not a vtkCompositePolyDataMapper")
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
 
     def clearColors(self, data_id: str) -> None:
-        db = self.get_object(data_id)
+        db = self.get_vtk_pipeline(data_id)
         mapper = db.mapper
         reader = db.reader
         output = reader.GetOutputDataObject(0)
diff --git a/src/opengeodeweb_viewer/rpc/generic/generic_protocols.py b/src/opengeodeweb_viewer/rpc/generic/generic_protocols.py
index f14a9c2..93ea9ea 100644
--- a/src/opengeodeweb_viewer/rpc/generic/generic_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/generic/generic_protocols.py
@@ -38,8 +38,7 @@ def register(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
-        data = self.get_data(data_id)
-        viewer_object = str(data["viewer_object"])
+        viewer_object = self.get_viewer_data(data_id).viewer_object
         if viewer_object == "mesh":
             self.mesh_protocols.registerMesh(specific_params)
         elif viewer_object == "model":
@@ -53,8 +52,7 @@ def deregister(self, rpc_params: RpcParams) -> None:
         params = schemas.Deregister.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
-        data = self.get_data(data_id)
-        viewer_object = str(data["viewer_object"])
+        viewer_object = self.get_viewer_data(data_id).viewer_object
         if viewer_object == "mesh":
             self.mesh_protocols.deregisterMesh(specific_params)
         elif viewer_object == "model":
diff --git a/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py b/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
index f9e6947..7399126 100644
--- a/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
@@ -12,6 +12,7 @@
 )
 from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkCellTypes
 from vtkmodules.vtkCommonExecutionModel import vtkAlgorithm
+from vtkmodules.vtkCommonDataModel import vtkPolyData
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.schemas import get_schemas_dict
 
@@ -21,7 +22,7 @@
     RpcParams,
 )
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
-from opengeodeweb_viewer.vtk_protocol import vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkPipeline
 from . import schemas
 
 
@@ -43,31 +44,12 @@ def registerMesh(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         try:
-            file_name = str(self.get_data(data_id)["viewable_file"])
+            file_name = str(self.get_viewer_data(data_id).viewable_file)
             reader = vtkXMLGenericDataObjectReader()
             mapper = vtkDataSetMapper()
             mapper.SetInputConnection(reader.GetOutputPort())
-            data = vtkData(reader, mapper)
+            data = VtkPipeline(reader, mapper)
             self.registerObject(data_id, file_name, data)
-            data_object = reader.GetOutput()
-            data_set = vtkDataSet.SafeDownCast(data_object)
-            cell_types = vtkCellTypes()
-            data_set.GetCellTypes(cell_types)
-            cell_data = cell_types.GetCellTypesArray()
-            max_id = -1
-            for t in range(cell_data.GetSize()):
-                t_id = cell_data.GetValue(t)
-                max_id = max(max_id, t_id)
-            print(f"{max_id=}", flush=True)
-            if max_id < 3:
-                data.max_dimension = "points"
-            elif max_id < 5:
-                data.max_dimension = "edges"
-            elif max_id < 7:
-                data.max_dimension = "polygons"
-            elif max_id >= 7:
-                data.max_dimension = "polyhedra"
-
         except Exception as e:
             print(f"Error registering mesh {data_id}: {str(e)}", flush=True)
             raise
@@ -123,7 +105,7 @@ def meshApplyTextures(self, rpc_params: RpcParams) -> None:
             texture = vtkTexture()
             texture.SetInputConnection(texture_reader.GetOutputPort())
             texture.InterpolateOn()
-            reader = self.get_object(mesh_id).reader
+            reader = self.get_vtk_pipeline(mesh_id).reader
             output = reader.GetOutputAsDataSet()
             point_data = output.GetPointData()
             for i in range(point_data.GetNumberOfArrays()):
@@ -131,29 +113,29 @@ def meshApplyTextures(self, rpc_params: RpcParams) -> None:
                 if array.GetName() == tex_info.texture_name:
                     point_data.SetTCoords(array)
                     break
-            actor = self.get_object(mesh_id).actor
+            actor = self.get_vtk_pipeline(mesh_id).actor
             actor.SetTexture(texture)
 
     def displayAttributeOnVertices(self, data_id: str, name: str) -> None:
-        reader = self.get_object(data_id).reader
+        reader = self.get_vtk_pipeline(data_id).reader
         points = reader.GetOutputAsDataSet().GetPointData()
         points.SetActiveScalars(name)
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointData()
         mapper.SetScalarRange(points.GetScalars().GetRange())
 
     def displayAttributeOnCells(self, data_id: str, name: str) -> None:
-        reader = self.get_object(data_id).reader
+        reader = self.get_vtk_pipeline(data_id).reader
         cells = reader.GetOutputAsDataSet().GetCellData()
         cells.SetActiveScalars(name)
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUseCellData()
         mapper.SetScalarRange(cells.GetScalars().GetRange())
 
     def displayScalarRange(self, data_id: str, minimum: float, maximum: float) -> None:
-        data = self.get_object(data_id)
+        data = self.get_vtk_pipeline(data_id)
         data.mapper.SetScalarRange(minimum, maximum)
         if hasattr(data, "color_map_points") and data.color_map_points:
             lut = vtkColorTransferFunction()
@@ -163,7 +145,7 @@ def displayScalarRange(self, data_id: str, minimum: float, maximum: float) -> No
             data.mapper.SetLookupTable(lut)
 
     def setupColorMap(self, data_id: str, points: list[list[float]]) -> None:
-        data = self.get_object(data_id)
+        data = self.get_vtk_pipeline(data_id)
         sorted_points = sorted(points, key=lambda x: x[0])
         points_min = sorted_points[0][0]
         points_max = sorted_points[-1][0]
diff --git a/src/opengeodeweb_viewer/rpc/model/model_protocols.py b/src/opengeodeweb_viewer/rpc/model/model_protocols.py
index 61c762a..3b23e0f 100644
--- a/src/opengeodeweb_viewer/rpc/model/model_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/model/model_protocols.py
@@ -17,7 +17,7 @@
     RpcParams,
 )
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
-from opengeodeweb_viewer.vtk_protocol import vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkPipeline
 from . import schemas
 
 
@@ -38,7 +38,7 @@ def registerModel(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         try:
-            file_name = str(self.get_data(data_id)["viewable_file"])
+            file_name = str(self.get_viewer_data(data_id).viewable_file)
             reader = vtkXMLMultiBlockDataReader()
             filter = vtkGeometryFilter()
             filter.SetInputConnection(reader.GetOutputPort())
@@ -46,7 +46,7 @@ def registerModel(self, rpc_params: RpcParams) -> None:
             mapper.SetInputConnection(filter.GetOutputPort())
             attributes = vtkCompositeDataDisplayAttributes()
             mapper.SetCompositeDataDisplayAttributes(attributes)
-            data = vtkData(reader, mapper, filter)
+            data = VtkPipeline(reader, mapper, filter)
             self.registerObject(data_id, file_name, data)
         except Exception as e:
             print(f"Error registering model {data_id}: {str(e)}", flush=True)
diff --git a/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py b/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
index 046508a..1cac7bc 100644
--- a/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
@@ -169,7 +169,7 @@ def updateData(self, rpc_params: RpcParams) -> None:
             rpc_params, self.viewer_schemas_dict["update_data"], self.viewer_prefix
         )
         params = schemas.UpdateData.from_dict(rpc_params)
-        data = self.get_object(params.id)
+        data = self.get_vtk_pipeline(params.id)
         reader = data.reader
         reader.Update()
         mapper = data.mapper
@@ -231,7 +231,7 @@ def pickedIds(self, rpc_params: RpcParams) -> dict[str, list[str]]:
         array_ids = []
         if picked_actor:
             for id in params.ids:
-                if self.get_object(id).actor == picked_actor:
+                if self.get_vtk_pipeline(id).actor == picked_actor:
                     array_ids.append(id)
                     break
 
diff --git a/src/opengeodeweb_viewer/vtk_protocol.py b/src/opengeodeweb_viewer/vtk_protocol.py
index 7b640bc..cda3315 100644
--- a/src/opengeodeweb_viewer/vtk_protocol.py
+++ b/src/opengeodeweb_viewer/vtk_protocol.py
@@ -27,14 +27,19 @@
 
 
 @dataclass
-class vtkData:
+class ViewerData:
+    id: str
+    viewable_file: str | None
+    viewer_object: str
+    viewer_elements_type: str
+
+
+@dataclass
+class VtkPipeline:
     reader: vtkXMLReader
     mapper: vtkMapper
     filter: vtkAlgorithm | None = None
     actor: vtkActor = field(default_factory=vtkActor)
-    max_dimension: Literal["points", "edges", "polygons", "polyhedra", "default"] = (
-        "default"
-    )
     color_map_points: list[list[float]] = field(default_factory=list)
 
 
@@ -57,8 +62,8 @@ def __init__(self) -> None:
     def get_data_base(self) -> Any:
         return self.getSharedObject("db")
 
-    def get_object(self, id: str) -> vtkData:
-        return cast(vtkData, self.get_data_base()[id])
+    def get_vtk_pipeline(self, id: str) -> VtkPipeline:
+        return cast(VtkPipeline, self.get_data_base()[id])
 
     def get_grid_scale(self) -> vtkCubeAxesActor | None:
         return cast(vtkCubeAxesActor | None, self.getSharedObject("grid_scale"))
@@ -78,16 +83,7 @@ def get_widget(self) -> vtkOrientationMarkerWidget | None:
     def set_widget(self, widget: vtkOrientationMarkerWidget) -> None:
         self.coreServer.setSharedObject("widget", widget)
 
-    def get_viewer_object_type(self, data_id: str) -> str:
-        data = self.get_data(data_id)
-        object_type = data.get("object_type")
-        if object_type == "mesh":
-            return "mesh"
-        elif object_type == "model":
-            return "model"
-        raise Exception(f"Unknown object_type type: {object_type}")
-
-    def get_data(self, data_id: str) -> dict[str, str | list[str] | None]:
+    def get_viewer_data(self, data_id: str) -> ViewerData:
         if Data is None:
             raise Exception("Data model not available")
 
@@ -99,20 +95,20 @@ def get_data(self, data_id: str) -> dict[str, str | list[str] | None]:
                 data = session.get(Data, data_id)
                 if not data:
                     raise Exception(f"Data with id {data_id} not found in database")
-
-                return {
-                    "id": data.id,
-                    "viewable_file": data.viewable_file,
-                    "viewer_object": data.viewer_object,
-                }
+                return ViewerData(
+                    id=data.id,
+                    viewable_file=data.viewable_file,
+                    viewer_object=data.viewer_object,
+                    viewer_elements_type=data.viewer_elements_type,
+                )
             except Exception as e:
                 print(f"Error fetching data {data_id}: {e}")
                 raise
 
     def get_data_file_path(self, data_id: str, filename: str | None = None) -> str:
         if filename is None:
-            data = self.get_data(data_id)
-            viewable_file = data["viewable_file"]
+            data = self.get_viewer_data(data_id)
+            viewable_file = data.viewable_file
             filename = str(viewable_file) if viewable_file is not None else ""
 
         data_folder_path = self.DATA_FOLDER_PATH
@@ -132,7 +128,7 @@ def render(self, view: int = -1) -> None:
             grid_scale.SetBounds(renderer_bounds)
         self.getSharedObject("publisher").imagePush({"view": view})
 
-    def register_object(self, id: str, data: vtkData) -> None:
+    def register_object(self, id: str, data: VtkPipeline) -> None:
         self.get_data_base()[id] = data
 
     def deregister_object(self, id: str) -> None:
diff --git a/tests/conftest.py b/tests/conftest.py
index 16f4fb7..04342e6 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -210,7 +210,9 @@ def configure_test_environment() -> Generator[None, None, None]:
 
 @pytest.fixture
 def dataset_factory() -> Callable[..., str]:
-    def create_dataset(*, id: str, viewable_file: str) -> str:
+    def create_dataset(
+        *, id: str, viewable_file: str, viewer_elements_type: str = "default"
+    ) -> str:
         session = get_session()
         viewer_object = "model" if viewable_file.lower().endswith(".vtm") else "mesh"
 
@@ -222,12 +224,14 @@ def create_dataset(*, id: str, viewable_file: str) -> str:
                     viewable_file=viewable_file,
                     geode_object=viewer_object,
                     viewer_object=viewer_object,
+                    viewer_elements_type=viewer_elements_type,
                 )
             )
         else:
             row.viewable_file = viewable_file
             row.geode_object = viewer_object
             row.viewer_object = viewer_object
+            row.viewer_elements_type = viewer_elements_type
         session.commit()
 
         data_folder = Path(os.environ["DATA_FOLDER_PATH"]) / id
diff --git a/tests/mesh/cells/test_mesh_cells_protocols.py b/tests/mesh/cells/test_mesh_cells_protocols.py
index 5ec42e4..c9218d4 100644
--- a/tests/mesh/cells/test_mesh_cells_protocols.py
+++ b/tests/mesh/cells/test_mesh_cells_protocols.py
@@ -15,7 +15,9 @@
 
 def test_register(server: ServerMonitor, dataset_factory: Callable[..., str]) -> None:
 
-    dataset_factory(id=mesh_id, viewable_file="regular_grid_2d.vti")
+    dataset_factory(
+        id=mesh_id, viewable_file="regular_grid_2d.vti", viewer_elements_type="polygons"
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
diff --git a/tests/mesh/edges/test_mesh_edges_protocols.py b/tests/mesh/edges/test_mesh_edges_protocols.py
index ff53df4..f72c80c 100644
--- a/tests/mesh/edges/test_mesh_edges_protocols.py
+++ b/tests/mesh/edges/test_mesh_edges_protocols.py
@@ -39,7 +39,9 @@ def test_edges_color(
 def test_edges_with_edged_curve(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
-    dataset_factory(id="123456789", viewable_file="edged_curve.vtp")
+    dataset_factory(
+        id="123456789", viewable_file="edged_curve.vtp", viewer_elements_type="edges"
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -66,7 +68,11 @@ def test_edges_vertex_attribute(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="attributed_edged_curve.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="attributed_edged_curve.vtp",
+        viewer_elements_type="edges",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -92,7 +98,11 @@ def test_edges_vertex_color_map(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="attributed_edged_curve.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="attributed_edged_curve.vtp",
+        viewer_elements_type="edges",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -135,7 +145,11 @@ def test_edges_vertex_color_map_range_update(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="attributed_edged_curve.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="attributed_edged_curve.vtp",
+        viewer_elements_type="edges",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -180,7 +194,11 @@ def test_edges_vertex_color_map_red_shift(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="attributed_edged_curve.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="attributed_edged_curve.vtp",
+        viewer_elements_type="edges",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -225,7 +243,11 @@ def test_edges_vertex_color_map_rainbow(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="attributed_edged_curve.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="attributed_edged_curve.vtp",
+        viewer_elements_type="edges",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
diff --git a/tests/mesh/points/test_mesh_points_protocols.py b/tests/mesh/points/test_mesh_points_protocols.py
index 0d2b086..99e94ce 100644
--- a/tests/mesh/points/test_mesh_points_protocols.py
+++ b/tests/mesh/points/test_mesh_points_protocols.py
@@ -59,7 +59,9 @@ def test_points_with_point_set(
 ) -> None:
     mesh_id = "44556677"
 
-    dataset_factory(id=mesh_id, viewable_file="points.vtp")
+    dataset_factory(
+        id=mesh_id, viewable_file="points.vtp", viewer_elements_type="points"
+    )
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
         [{"id": mesh_id}],
diff --git a/tests/mesh/polygons/test_mesh_polygons_protocols.py b/tests/mesh/polygons/test_mesh_polygons_protocols.py
index 7bb7279..833a78a 100644
--- a/tests/mesh/polygons/test_mesh_polygons_protocols.py
+++ b/tests/mesh/polygons/test_mesh_polygons_protocols.py
@@ -63,7 +63,11 @@ def test_polygons_polygon_attribute(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
 
-    dataset_factory(id="123456789", viewable_file="triangulated_surface2d.vtp")
+    dataset_factory(
+        id="123456789",
+        viewable_file="triangulated_surface2d.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -255,7 +259,11 @@ def test_polygons_polygon_color_map(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="triangulated_surface2d.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="triangulated_surface2d.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -298,7 +306,11 @@ def test_polygons_polygon_color_map_range_update(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="triangulated_surface2d.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="triangulated_surface2d.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -346,7 +358,11 @@ def test_polygons_polygon_color_map_red_shift(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="triangulated_surface2d.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="triangulated_surface2d.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -393,7 +409,11 @@ def test_polygons_polygon_color_map_rainbow(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     mesh_id = "123456789"
-    dataset_factory(id=mesh_id, viewable_file="triangulated_surface2d.vtp")
+    dataset_factory(
+        id=mesh_id,
+        viewable_file="triangulated_surface2d.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
diff --git a/tests/mesh/polyhedra/test_mesh_polyhedra_protocols.py b/tests/mesh/polyhedra/test_mesh_polyhedra_protocols.py
index f5af4e8..ccff8f9 100644
--- a/tests/mesh/polyhedra/test_mesh_polyhedra_protocols.py
+++ b/tests/mesh/polyhedra/test_mesh_polyhedra_protocols.py
@@ -14,7 +14,11 @@
 def test_register_mesh(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
-    dataset_factory(id="123456789", viewable_file="polyhedron_attribute.vtu")
+    dataset_factory(
+        id="123456789",
+        viewable_file="polyhedron_attribute.vtu",
+        viewer_elements_type="polyhedra",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
diff --git a/tests/mesh/test_mesh_protocols.py b/tests/mesh/test_mesh_protocols.py
index 201e2b2..9ab5e87 100644
--- a/tests/mesh/test_mesh_protocols.py
+++ b/tests/mesh/test_mesh_protocols.py
@@ -6,7 +6,9 @@
 def test_register_mesh(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
-    dataset_factory(id="123456789", viewable_file="hat.vtp")
+    dataset_factory(
+        id="123456789", viewable_file="hat.vtp", viewer_elements_type="polygons"
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -62,7 +64,11 @@ def test_apply_textures(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     test_register_mesh(server, dataset_factory)
-    texture_entry = dataset_factory(id="987654321", viewable_file="hat_lambert2SG.vti")
+    texture_entry = dataset_factory(
+        id="987654321",
+        viewable_file="hat_lambert2SG.vti",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix
diff --git a/tests/test_generic_protocols.py b/tests/test_generic_protocols.py
index c75bda1..bd055cd 100644
--- a/tests/test_generic_protocols.py
+++ b/tests/test_generic_protocols.py
@@ -7,7 +7,9 @@ def test_register_mesh(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
     data_id = "123456789"
-    dataset_factory(id=data_id, viewable_file="hat.vtp")
+    dataset_factory(
+        id=data_id, viewable_file="hat.vtp", viewer_elements_type="polygons"
+    )
 
     server.call(
         VtkGenericView.generic_prefix
diff --git a/tests/test_utils_protocols.py b/tests/test_utils_protocols.py
index 5ebe6b5..efbf782 100644
--- a/tests/test_utils_protocols.py
+++ b/tests/test_utils_protocols.py
@@ -12,7 +12,7 @@ def test_reset_project_after_import(
 ) -> None:
     # Mock
     pre_id = "123456789"
-    dataset_factory(id=pre_id, viewable_file="hat.vtp")
+    dataset_factory(id=pre_id, viewable_file="hat.vtp", viewer_elements_type="polygons")
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
         [{"id": pre_id}],
@@ -25,7 +25,9 @@ def test_reset_project_after_import(
         session.commit()
 
     post_id = "987654321"
-    dataset_factory(id=post_id, viewable_file="hat.vtp")
+    dataset_factory(
+        id=post_id, viewable_file="hat.vtp", viewer_elements_type="polygons"
+    )
 
     server.call(
         VtkUtilsView.utils_prefix
diff --git a/tests/test_viewer_protocols.py b/tests/test_viewer_protocols.py
index fb8e4ac..9434ef2 100644
--- a/tests/test_viewer_protocols.py
+++ b/tests/test_viewer_protocols.py
@@ -193,7 +193,9 @@ def test_picked_ids(server: ServerMonitor, dataset_factory: Callable[..., str])
 
 def test_grid_scale(server: ServerMonitor, dataset_factory: Callable[..., str]) -> None:
     data_id = "123456789"
-    dataset_factory(id=data_id, viewable_file="hat.vtp")
+    dataset_factory(
+        id=data_id, viewable_file="hat.vtp", viewer_elements_type="polygons"
+    )
     server.call(
         VtkViewerView.viewer_prefix
         + VtkViewerView.viewer_schemas_dict["reset_visualization"]["rpc"],
@@ -283,7 +285,11 @@ def test_render(server: ServerMonitor, dataset_factory: Callable[..., str]) -> N
 def test_set_z_scaling(
     server: ServerMonitor, dataset_factory: Callable[..., str]
 ) -> None:
-    dataset_factory(id="123456789", viewable_file="polygon_attribute.vtp")
+    dataset_factory(
+        id="123456789",
+        viewable_file="polygon_attribute.vtp",
+        viewer_elements_type="polygons",
+    )
 
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
@@ -291,7 +297,11 @@ def test_set_z_scaling(
     )
     assert server.compare_image("viewer/polygon_attribute.jpeg") == True
 
-    dataset_factory(id="987654321", viewable_file="vertex_attribute.vtp")
+    dataset_factory(
+        id="987654321",
+        viewable_file="vertex_attribute.vtp",
+        viewer_elements_type="polygons",
+    )
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
         [{"id": "987654321"}],
@@ -333,7 +343,9 @@ def test_combined_scaling_and_grid(
         + VtkViewerView.viewer_schemas_dict["reset_visualization"]["rpc"],
     )
     assert server.compare_image("viewer/reset_visualization.jpeg") == True
-    dataset_factory(id="123456789", viewable_file="hat.vtp")
+    dataset_factory(
+        id="123456789", viewable_file="hat.vtp", viewer_elements_type="polygons"
+    )
     server.call(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
         [{"id": "123456789"}],