diff --git a/src/openrct2-ui/windows/EditorBottomToolbar.cpp b/src/openrct2-ui/windows/EditorBottomToolbar.cpp
index d02c7b325d..a27718e52a 100644
--- a/src/openrct2-ui/windows/EditorBottomToolbar.cpp
+++ b/src/openrct2-ui/windows/EditorBottomToolbar.cpp
@@ -176,8 +176,8 @@ static bool window_editor_bottom_toolbar_check_object_selection()
 {
     rct_window* w;
 
-    int32_t missingObjectType = Editor::CheckObjectSelection();
-    if (missingObjectType < 0)
+    ObjectType missingObjectType = Editor::CheckObjectSelection();
+    if (missingObjectType == ObjectType::None)
     {
         window_close_by_class(WC_EDITOR_OBJECT_SELECTION);
         return true;
diff --git a/src/openrct2-ui/windows/EditorInventionsList.cpp b/src/openrct2-ui/windows/EditorInventionsList.cpp
index e174b48eac..cd42523095 100644
--- a/src/openrct2-ui/windows/EditorInventionsList.cpp
+++ b/src/openrct2-ui/windows/EditorInventionsList.cpp
@@ -126,12 +126,12 @@ static void move_research_item(ResearchItem* beforeItem, int32_t scrollIndex);
 static void research_rides_setup()
 {
     // Reset all objects to not required
-    for (uint8_t objectType = ObjectType::Ride; objectType < ObjectType::Count; objectType++)
+    for (uint8_t objectType = EnumValue(ObjectType::Ride); objectType < EnumValue(ObjectType::Count); objectType++)
     {
         auto maxObjects = object_entry_group_counts[objectType];
         for (int32_t i = 0; i < maxObjects; i++)
         {
-            Editor::ClearSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_ALL);
+            Editor::ClearSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_ALL);
         }
     }
 
@@ -531,7 +531,7 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
         return;
 
     // Preview image
-    int32_t objectEntryType = ObjectType::SceneryGroup;
+    ObjectType objectEntryType = ObjectType::SceneryGroup;
     if (researchItem->type == Research::EntryType::Ride)
         objectEntryType = ObjectType::Ride;
 
diff --git a/src/openrct2-ui/windows/EditorObjectSelection.cpp b/src/openrct2-ui/windows/EditorObjectSelection.cpp
index 8f22e05b0f..8963d9e684 100644
--- a/src/openrct2-ui/windows/EditorObjectSelection.cpp
+++ b/src/openrct2-ui/windows/EditorObjectSelection.cpp
@@ -64,7 +64,7 @@ enum
 static constexpr uint8_t _numSourceGameItems = 8;
 
 static uint32_t _filter_flags;
-static uint16_t _filter_object_counts[ObjectType::Count];
+static uint16_t _filter_object_counts[EnumValue(ObjectType::Count)];
 
 static char _filter_string[MAX_PATH];
 
@@ -222,7 +222,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item);
 static void filter_update_counts();
 
 static std::string object_get_description(const Object* object);
-static int32_t get_selected_object_type(rct_window* w);
+static ObjectType get_selected_object_type(rct_window* w);
 
 enum
 {
@@ -1224,7 +1224,7 @@ static void window_editor_object_set_page(rct_window* w, int32_t page)
     w->scrolls[0].v_top = 0;
     w->frame_no = 0;
 
-    if (page == ObjectType::Ride)
+    if (page == EnumValue(ObjectType::Ride))
     {
         _listSortType = RIDE_SORT_TYPE;
         _listSortDescending = false;
@@ -1314,7 +1314,7 @@ static void editor_load_selected_objects()
                 else if (!(gScreenFlags & SCREEN_FLAGS_EDITOR))
                 {
                     // Defaults selected items to researched (if in-game)
-                    uint8_t objectType = entry->GetType();
+                    ObjectType objectType = entry->GetType();
                     auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
                     if (objectType == ObjectType::Ride)
                     {
@@ -1474,7 +1474,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
     switch (item->ObjectEntry.GetType())
     {
         case ObjectType::Ride:
-
+        {
             uint8_t rideType = 0;
             for (int32_t i = 0; i < MAX_RIDE_TYPES_PER_RIDE_ENTRY; i++)
             {
@@ -1485,6 +1485,25 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
                 }
             }
             return (_filter_flags & (1 << (RideTypeDescriptors[rideType].Category + _numSourceGameItems))) != 0;
+        }
+        case ObjectType::SmallScenery:
+        case ObjectType::LargeScenery:
+        case ObjectType::Walls:
+        case ObjectType::Banners:
+        case ObjectType::Paths:
+        case ObjectType::PathBits:
+        case ObjectType::SceneryGroup:
+        case ObjectType::ParkEntrance:
+        case ObjectType::Water:
+        case ObjectType::ScenarioText:
+        case ObjectType::TerrainSurface:
+        case ObjectType::TerrainEdge:
+        case ObjectType::Station:
+        case ObjectType::Music:
+        case ObjectType::Count:
+        case ObjectType::None:
+            //This function works only with ObjectType::Ride.
+            break;
     }
     return true;
 }
@@ -1539,11 +1558,11 @@ static std::string object_get_description(const Object* object)
     }
 }
 
-static int32_t get_selected_object_type(rct_window* w)
+static ObjectType get_selected_object_type(rct_window* w)
 {
     auto tab = w->selected_tab;
-    if (tab >= ObjectType::ScenarioText)
-        return tab + 1;
+    if (tab >= EnumValue(ObjectType::ScenarioText))
+        return static_cast<ObjectType>(tab + 1);
     else
-        return tab;
+        return static_cast<ObjectType>(tab);
 }
diff --git a/src/openrct2-ui/windows/Footpath.cpp b/src/openrct2-ui/windows/Footpath.cpp
index 4bea82a56b..03f8158299 100644
--- a/src/openrct2-ui/windows/Footpath.cpp
+++ b/src/openrct2-ui/windows/Footpath.cpp
@@ -1218,7 +1218,7 @@ static bool footpath_select_default()
 {
     // Select first available footpath
     int32_t footpathId = -1;
-    for (int32_t i = 0; i < object_entry_group_counts[ObjectType::Paths]; i++)
+    for (int32_t i = 0; i < object_entry_group_counts[EnumValue(ObjectType::Paths)]; i++)
     {
         PathSurfaceEntry* pathEntry = get_path_surface_entry(i);
         if (pathEntry != nullptr)
diff --git a/src/openrct2/CmdlineSprite.cpp b/src/openrct2/CmdlineSprite.cpp
index 361be71491..26ab95d346 100644
--- a/src/openrct2/CmdlineSprite.cpp
+++ b/src/openrct2/CmdlineSprite.cpp
@@ -468,7 +468,7 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
             return -1;
         }
         auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
-        uint8_t objectType = entry->GetType();
+        ObjectType objectType = entry->GetType();
 
         auto& objManager = context->GetObjectManager();
         auto metaObject = objManager.GetLoadedObject(objectType, entryIndex);
diff --git a/src/openrct2/Editor.cpp b/src/openrct2/Editor.cpp
index dbdbbe3015..f84a3dd48e 100644
--- a/src/openrct2/Editor.cpp
+++ b/src/openrct2/Editor.cpp
@@ -445,7 +445,7 @@ namespace Editor
      *
      *  rct2: 0x006AB9B8
      */
-    int32_t CheckObjectSelection()
+    ObjectType CheckObjectSelection()
     {
         bool isTrackDesignerManager = gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER);
 
@@ -479,7 +479,7 @@ namespace Editor
             }
         }
 
-        return -1;
+        return ObjectType::None;
     }
 
     /**
@@ -541,7 +541,7 @@ namespace Editor
         return result;
     }
 
-    void ClearSelectedObject(int32_t objectType, size_t index, uint32_t flags)
+    void ClearSelectedObject(ObjectType objectType, size_t index, uint32_t flags)
     {
         auto& list = _editorSelectedObjectFlags[objectType];
         if (list.size() <= index)
@@ -551,7 +551,7 @@ namespace Editor
         list[index] &= ~flags;
     }
 
-    void SetSelectedObject(int32_t objectType, size_t index, uint32_t flags)
+    void SetSelectedObject(ObjectType objectType, size_t index, uint32_t flags)
     {
         auto& list = _editorSelectedObjectFlags[objectType];
         if (list.size() <= index)
diff --git a/src/openrct2/Editor.h b/src/openrct2/Editor.h
index 5673cdf60c..8cbc06e3d6 100644
--- a/src/openrct2/Editor.h
+++ b/src/openrct2/Editor.h
@@ -12,6 +12,8 @@
 
 #include "common.h"
 
+#include <src/openrct2/object/Object.h>
+
 namespace Editor
 {
     void Load();
@@ -21,13 +23,13 @@ namespace Editor
     bool LoadLandscape(const utf8* path);
 
     bool CheckPark();
-    int32_t CheckObjectSelection();
+    ObjectType CheckObjectSelection();
 
     void OpenWindowsForCurrentStep();
 
     uint8_t GetSelectedObjectFlags(int32_t objectType, size_t index);
-    void ClearSelectedObject(int32_t objectType, size_t index, uint32_t flags);
-    void SetSelectedObject(int32_t objectType, size_t index, uint32_t flags);
+    void ClearSelectedObject(ObjectType objectType, size_t index, uint32_t flags);
+    void SetSelectedObject(ObjectType objectType, size_t index, uint32_t flags);
 } // namespace Editor
 
 enum RCT2_EDITOR_STEP
diff --git a/src/openrct2/EditorObjectSelectionSession.cpp b/src/openrct2/EditorObjectSelectionSession.cpp
index 882a6e41a5..a2502d021b 100644
--- a/src/openrct2/EditorObjectSelectionSession.cpp
+++ b/src/openrct2/EditorObjectSelectionSession.cpp
@@ -30,8 +30,8 @@
 
 bool _maxObjectsWasHit;
 std::vector<uint8_t> _objectSelectionFlags;
-int32_t _numSelectedObjectsForType[ObjectType::Count];
-static int32_t _numAvailableObjectsForType[ObjectType::Count];
+int32_t _numSelectedObjectsForType[EnumValue(ObjectType::Count)];
+static int32_t _numAvailableObjectsForType[EnumValue(ObjectType::Count)];
 
 static void setup_in_use_selection_flags();
 static void setup_track_designer_objects();
@@ -50,7 +50,7 @@ static void setup_track_manager_objects()
     {
         uint8_t* selectionFlags = &_objectSelectionFlags[i];
         const ObjectRepositoryItem* item = &items[i];
-        uint8_t object_type = item->ObjectEntry.GetType();
+        ObjectType object_type = item->ObjectEntry.GetType();
         if (object_type == ObjectType::Ride)
         {
             *selectionFlags |= OBJECT_SELECTION_FLAG_6;
@@ -79,7 +79,7 @@ static void setup_track_designer_objects()
     {
         uint8_t* selectionFlags = &_objectSelectionFlags[i];
         const ObjectRepositoryItem* item = &items[i];
-        uint8_t objectType = item->ObjectEntry.GetType();
+        ObjectType objectType = item->ObjectEntry.GetType();
         if (objectType == ObjectType::Ride)
         {
             *selectionFlags |= OBJECT_SELECTION_FLAG_6;
@@ -107,16 +107,16 @@ void setup_in_use_selection_flags()
 {
     auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
 
-    for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
+    for (uint8_t objectType = 0; objectType < EnumValue(ObjectType::Count); objectType++)
     {
         for (int32_t i = 0; i < object_entry_group_counts[objectType]; i++)
         {
-            Editor::ClearSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_ALL);
+            Editor::ClearSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_ALL);
 
-            auto loadedObj = objectMgr.GetLoadedObject(objectType, i);
+            auto loadedObj = objectMgr.GetLoadedObject(static_cast<ObjectType>(objectType), i);
             if (loadedObj != nullptr)
             {
-                Editor::SetSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_2);
+                Editor::SetSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_2);
             }
         }
     }
@@ -135,7 +135,7 @@ void setup_in_use_selection_flags()
                 break;
             case TILE_ELEMENT_TYPE_PATH:
                 type = iter.element->AsPath()->GetSurfaceEntryIndex();
-                assert(type < object_entry_group_counts[ObjectType::Paths]);
+                assert(type < object_entry_group_counts[EnumValue(ObjectType::Paths)]);
                 Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
 
                 if (iter.element->AsPath()->HasAddition())
@@ -146,7 +146,7 @@ void setup_in_use_selection_flags()
                 break;
             case TILE_ELEMENT_TYPE_SMALL_SCENERY:
                 type = iter.element->AsSmallScenery()->GetEntryIndex();
-                assert(type < object_entry_group_counts[ObjectType::SmallScenery]);
+                assert(type < object_entry_group_counts[EnumValue(ObjectType::SmallScenery)]);
                 Editor::SetSelectedObject(ObjectType::SmallScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_ENTRANCE:
@@ -159,17 +159,17 @@ void setup_in_use_selection_flags()
                 Editor::SetSelectedObject(ObjectType::ParkEntrance, 0, OBJECT_SELECTION_FLAG_SELECTED);
 
                 type = iter.element->AsEntrance()->GetPathType();
-                assert(type < object_entry_group_counts[ObjectType::Paths]);
+                assert(type < object_entry_group_counts[EnumValue(ObjectType::Paths)]);
                 Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_WALL:
                 type = iter.element->AsWall()->GetEntryIndex();
-                assert(type < object_entry_group_counts[ObjectType::Walls]);
+                assert(type < object_entry_group_counts[EnumValue(ObjectType::Walls)]);
                 Editor::SetSelectedObject(ObjectType::Walls, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_LARGE_SCENERY:
                 type = iter.element->AsLargeScenery()->GetEntryIndex();
-                assert(type < object_entry_group_counts[ObjectType::LargeScenery]);
+                assert(type < object_entry_group_counts[EnumValue(ObjectType::LargeScenery)]);
                 Editor::SetSelectedObject(ObjectType::LargeScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_BANNER:
@@ -178,7 +178,7 @@ void setup_in_use_selection_flags()
                 if (banner != nullptr)
                 {
                     type = banner->type;
-                    assert(type < object_entry_group_counts[ObjectType::Banners]);
+                    assert(type < object_entry_group_counts[EnumValue(ObjectType::Banners)]);
                     Editor::SetSelectedObject(ObjectType::Banners, type, OBJECT_SELECTION_FLAG_SELECTED);
                 }
                 break;
@@ -204,7 +204,7 @@ void setup_in_use_selection_flags()
         const ObjectRepositoryItem* item = &items[i];
         *selectionFlags &= ~OBJECT_SELECTION_FLAG_IN_USE;
 
-        uint8_t entryType;
+        ObjectType entryType;
         ObjectEntryIndex entryIndex;
         if (find_object_in_entry_group(&item->ObjectEntry, &entryType, &entryIndex))
         {
@@ -230,7 +230,7 @@ void sub_6AB211()
     int32_t numObjects = static_cast<int32_t>(object_repository_get_items_count());
     _objectSelectionFlags = std::vector<uint8_t>(numObjects);
 
-    for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
+    for (uint8_t objectType = 0; objectType < EnumValue(ObjectType::Count); objectType++)
     {
         _numSelectedObjectsForType[objectType] = 0;
         _numAvailableObjectsForType[objectType] = 0;
@@ -239,7 +239,7 @@ void sub_6AB211()
     const ObjectRepositoryItem* items = object_repository_get_items();
     for (int32_t i = 0; i < numObjects; i++)
     {
-        uint8_t objectType = items[i].ObjectEntry.GetType();
+        ObjectType objectType = items[i].ObjectEntry.GetType();
         _numAvailableObjectsForType[objectType]++;
     }
 
@@ -284,7 +284,7 @@ void editor_object_flags_free()
  */
 static void remove_selected_objects_from_research(const rct_object_entry* installedObject)
 {
-    uint8_t entry_type;
+    ObjectType entry_type;
     ObjectEntryIndex entry_index;
     if (!find_object_in_entry_group(installedObject, &entry_type, &entry_index))
         return;
@@ -450,7 +450,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
             return false;
         }
 
-        uint8_t objectType = item->ObjectEntry.GetType();
+        ObjectType objectType = item->ObjectEntry.GetType();
         if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
         {
             for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
@@ -459,7 +459,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
             }
         }
 
-        _numSelectedObjectsForType[objectType]--;
+        _numSelectedObjectsForType[EnumValue(objectType)]--;
         *selectionFlags &= ~OBJECT_SELECTION_FLAG_SELECTED;
         return true;
     }
@@ -477,8 +477,8 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
             return true;
         }
 
-        uint8_t objectType = item->ObjectEntry.GetType();
-        uint16_t maxObjects = object_entry_group_counts[objectType];
+        ObjectType objectType = item->ObjectEntry.GetType();
+        uint16_t maxObjects = object_entry_group_counts[EnumValue(objectType)];
         if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
         {
             maxObjects = 4;
@@ -517,7 +517,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
             return false;
         }
 
-        _numSelectedObjectsForType[objectType]++;
+        _numSelectedObjectsForType[EnumValue(objectType)]++;
 
         *selectionFlags |= OBJECT_SELECTION_FLAG_SELECTED;
         return true;
@@ -537,14 +537,14 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
     return window_editor_object_selection_select_object(isMasterObject, flags, item);
 }
 
-bool editor_check_object_group_at_least_one_selected(int32_t checkObjectType)
+bool editor_check_object_group_at_least_one_selected(ObjectType checkObjectType)
 {
     int32_t numObjects = static_cast<int32_t>(object_repository_get_items_count());
     const ObjectRepositoryItem* items = object_repository_get_items();
 
     for (int32_t i = 0; i < numObjects; i++)
     {
-        uint8_t objectType = items[i].ObjectEntry.GetType();
+        ObjectType objectType = items[i].ObjectEntry.GetType();
         if (checkObjectType == objectType && (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED))
         {
             return true;
@@ -570,7 +570,7 @@ int32_t editor_remove_unused_objects()
                 && !(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED))
             {
                 const ObjectRepositoryItem* item = &items[i];
-                uint8_t objectType = item->ObjectEntry.GetType();
+                ObjectType objectType = item->ObjectEntry.GetType();
 
                 if (objectType >= ObjectType::SceneryGroup)
                 {
diff --git a/src/openrct2/EditorObjectSelectionSession.h b/src/openrct2/EditorObjectSelectionSession.h
index 729c0b94e5..c93b940cd9 100644
--- a/src/openrct2/EditorObjectSelectionSession.h
+++ b/src/openrct2/EditorObjectSelectionSession.h
@@ -11,6 +11,7 @@
 
 #include "common.h"
 #include "object/Object.h"
+#include "util/Util.h"
 
 #include <vector>
 
@@ -24,9 +25,9 @@ enum EDITOR_INPUT_FLAGS
 
 extern bool _maxObjectsWasHit;
 extern std::vector<uint8_t> _objectSelectionFlags;
-extern int32_t _numSelectedObjectsForType[ObjectType::Count];
+extern int32_t _numSelectedObjectsForType[EnumValue(ObjectType::Count)];
 
-bool editor_check_object_group_at_least_one_selected(int32_t objectType);
+bool editor_check_object_group_at_least_one_selected(ObjectType checkObjectType);
 void editor_object_flags_free();
 void unload_unselected_objects();
 void sub_6AB211();
diff --git a/src/openrct2/interface/InteractiveConsole.cpp b/src/openrct2/interface/InteractiveConsole.cpp
index 1c4a5abaa5..33b13d1da1 100644
--- a/src/openrct2/interface/InteractiveConsole.cpp
+++ b/src/openrct2/interface/InteractiveConsole.cpp
@@ -1073,7 +1073,7 @@ static int32_t cc_load_object(InteractiveConsole& console, const arguments_t& ar
         }
         auto groupIndex = object_manager_get_loaded_object_entry_index(loadedObject);
 
-        uint8_t objectType = entry->GetType();
+        ObjectType objectType = entry->GetType();
         if (objectType == ObjectType::Ride)
         {
             // Automatically research the ride so it's supported by the game.
diff --git a/src/openrct2/object/Object.h b/src/openrct2/object/Object.h
index fb9ef58ffa..ab4cc42b5d 100644
--- a/src/openrct2/object/Object.h
+++ b/src/openrct2/object/Object.h
@@ -23,7 +23,7 @@ using ObjectEntryIndex = uint16_t;
 constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_NULL = std::numeric_limits<ObjectEntryIndex>::max();
 
 // First 0xF of rct_object_entry->flags
-enum ObjectType : uint8_t
+enum class ObjectType : uint8_t
 {
     Ride,
     SmallScenery,
@@ -41,7 +41,8 @@ enum ObjectType : uint8_t
     Station,
     Music,
 
-    Count
+    Count,
+    None=255
 };
 
 enum OBJECT_SELECTION_FLAGS
@@ -100,9 +101,9 @@ struct rct_object_entry
 
     void SetName(const std::string_view& value);
 
-    uint8_t GetType() const
+    ObjectType GetType() const
     {
-        return flags & 0x0F;
+        return static_cast<ObjectType>(flags & 0x0F);
     }
 
     std::optional<uint8_t> GetSceneryType() const;
@@ -264,7 +265,7 @@ public:
     {
     }
 
-    virtual uint8_t GetObjectType() const final
+    virtual ObjectType GetObjectType() const final
     {
         return _objectEntry.GetType();
     }
@@ -304,12 +305,12 @@ extern int32_t object_entry_group_encoding[];
 bool object_entry_is_empty(const rct_object_entry* entry);
 bool object_entry_compare(const rct_object_entry* a, const rct_object_entry* b);
 int32_t object_calculate_checksum(const rct_object_entry* entry, const void* data, size_t dataLength);
-bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex);
+bool find_object_in_entry_group(const rct_object_entry* entry, ObjectType* entry_type, ObjectEntryIndex* entryIndex);
 void object_create_identifier_name(char* string_buffer, size_t size, const rct_object_entry* object);
 
 const rct_object_entry* object_list_find(rct_object_entry* entry);
 
 void object_entry_get_name_fixed(utf8* buffer, size_t bufferSize, const rct_object_entry* entry);
 
-void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index);
-const rct_object_entry* object_entry_get_entry(int32_t objectType, ObjectEntryIndex index);
+void* object_entry_get_chunk(ObjectType objectType, ObjectEntryIndex index);
+const rct_object_entry* object_entry_get_entry(ObjectType objectType, ObjectEntryIndex index);
diff --git a/src/openrct2/object/ObjectFactory.cpp b/src/openrct2/object/ObjectFactory.cpp
index f0876756fa..a2bb546448 100644
--- a/src/openrct2/object/ObjectFactory.cpp
+++ b/src/openrct2/object/ObjectFactory.cpp
@@ -320,7 +320,7 @@ namespace ObjectFactory
         return result;
     }
 
-    static uint8_t ParseObjectType(const std::string& s)
+    static ObjectType ParseObjectType(const std::string& s)
     {
         if (s == "ride")
             return ObjectType::Ride;
@@ -348,7 +348,7 @@ namespace ObjectFactory
             return ObjectType::TerrainEdge;
         if (s == "station")
             return ObjectType::Station;
-        return 0xFF;
+        return ObjectType::None;
     }
 
     std::unique_ptr<Object> CreateObjectFromZipFile(IObjectRepository& objectRepository, const std::string_view& path)
diff --git a/src/openrct2/object/ObjectList.cpp b/src/openrct2/object/ObjectList.cpp
index 2a39285cbf..aeac107c08 100644
--- a/src/openrct2/object/ObjectList.cpp
+++ b/src/openrct2/object/ObjectList.cpp
@@ -84,16 +84,16 @@ void object_create_identifier_name(char* string_buffer, size_t size, const rct_o
  * bl = entry_index
  * ecx = entry_type
  */
-bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex)
+bool find_object_in_entry_group(const rct_object_entry* entry, ObjectType* entry_type, ObjectEntryIndex* entryIndex)
 {
-    int32_t objectType = entry->GetType();
+    ObjectType objectType = entry->GetType();
     if (objectType >= ObjectType::Count)
     {
         return false;
     }
 
     auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto maxObjects = object_entry_group_counts[objectType];
+    auto maxObjects = object_entry_group_counts[EnumValue(objectType)];
     for (int32_t i = 0; i < maxObjects; i++)
     {
         auto loadedObj = objectMgr.GetLoadedObject(objectType, i);
@@ -111,9 +111,9 @@ bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_ty
     return false;
 }
 
-void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex)
+void get_type_entry_index(size_t index, ObjectType* outObjectType, ObjectEntryIndex* outEntryIndex)
 {
-    uint8_t objectType = ObjectType::Ride;
+    uint8_t objectType = EnumValue(ObjectType::Ride);
     for (size_t groupCount : object_entry_group_counts)
     {
         if (index >= groupCount)
@@ -128,14 +128,14 @@ void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex
     }
 
     if (outObjectType != nullptr)
-        *outObjectType = objectType;
+        *outObjectType = static_cast<ObjectType>(objectType);
     if (outEntryIndex != nullptr)
         *outEntryIndex = static_cast<ObjectEntryIndex>(index);
 }
 
 const rct_object_entry* get_loaded_object_entry(size_t index)
 {
-    uint8_t objectType;
+    ObjectType objectType;
     ObjectEntryIndex entryIndex;
     get_type_entry_index(index, &objectType, &entryIndex);
 
@@ -144,7 +144,7 @@ const rct_object_entry* get_loaded_object_entry(size_t index)
 
 void* get_loaded_object_chunk(size_t index)
 {
-    uint8_t objectType;
+    ObjectType objectType;
     ObjectEntryIndex entryIndex;
     get_type_entry_index(index, &objectType, &entryIndex);
     return object_entry_get_chunk(objectType, entryIndex);
@@ -157,10 +157,10 @@ void object_entry_get_name_fixed(utf8* buffer, size_t bufferSize, const rct_obje
     buffer[bufferSize - 1] = 0;
 }
 
-void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index)
+void* object_entry_get_chunk(ObjectType objectType, ObjectEntryIndex index)
 {
     ObjectEntryIndex objectIndex = index;
-    for (int32_t i = 0; i < objectType; i++)
+    for (int32_t i = 0; i < EnumValue(objectType); i++)
     {
         objectIndex += object_entry_group_counts[i];
     }
@@ -175,7 +175,7 @@ void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index)
     return result;
 }
 
-const rct_object_entry* object_entry_get_entry(int32_t objectType, ObjectEntryIndex index)
+const rct_object_entry* object_entry_get_entry(ObjectType objectType, ObjectEntryIndex index)
 {
     const rct_object_entry* result = nullptr;
     auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
diff --git a/src/openrct2/object/ObjectList.h b/src/openrct2/object/ObjectList.h
index 8fda068f32..62cbe2cdca 100644
--- a/src/openrct2/object/ObjectList.h
+++ b/src/openrct2/object/ObjectList.h
@@ -17,6 +17,6 @@
 #include "../world/Water.h"
 #include "ObjectLimits.h"
 
-void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex);
+void get_type_entry_index(size_t index, ObjectType* outObjectType, ObjectEntryIndex* outEntryIndex);
 const rct_object_entry* get_loaded_object_entry(size_t index);
 void* get_loaded_object_chunk(size_t index);
diff --git a/src/openrct2/object/ObjectManager.cpp b/src/openrct2/object/ObjectManager.cpp
index 629c6ee7a5..c9c31f77e2 100644
--- a/src/openrct2/object/ObjectManager.cpp
+++ b/src/openrct2/object/ObjectManager.cpp
@@ -14,6 +14,7 @@
 #include "../core/Console.hpp"
 #include "../core/Memory.hpp"
 #include "../localisation/StringIds.h"
+#include "../util/Util.h"
 #include "FootpathItemObject.h"
 #include "LargeSceneryObject.h"
 #include "Object.h"
@@ -65,7 +66,7 @@ public:
         return _loadedObjects[index].get();
     }
 
-    Object* GetLoadedObject(int32_t objectType, size_t index) override
+    Object* GetLoadedObject(ObjectType objectType, size_t index) override
     {
         if (index >= static_cast<size_t>(object_entry_group_counts[objectType]))
         {
@@ -684,7 +685,7 @@ private:
         }
 
         // Build object lists
-        auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[ObjectType::Ride]);
+        auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[EnumValue(ObjectType::Ride)]);
         for (size_t i = 0; i < maxRideObjects; i++)
         {
             auto rideObject = static_cast<RideObject*>(GetLoadedObject(ObjectType::Ride, i));
diff --git a/src/openrct2/object/ObjectManager.h b/src/openrct2/object/ObjectManager.h
index 85e8051eb6..3ea36a0632 100644
--- a/src/openrct2/object/ObjectManager.h
+++ b/src/openrct2/object/ObjectManager.h
@@ -25,7 +25,7 @@ struct IObjectManager
     }
 
     virtual Object* GetLoadedObject(size_t index) abstract;
-    virtual Object* GetLoadedObject(int32_t objectType, size_t index) abstract;
+    virtual Object* GetLoadedObject(ObjectType objectType, size_t index) abstract;
     virtual Object* GetLoadedObject(const rct_object_entry* entry) abstract;
     virtual ObjectEntryIndex GetLoadedObjectEntryIndex(const Object* object) abstract;
     virtual std::vector<rct_object_entry> GetInvalidObjects(const rct_object_entry* entries) abstract;
diff --git a/src/openrct2/object/ObjectRepository.cpp b/src/openrct2/object/ObjectRepository.cpp
index 92c358cde9..4fd7c75d65 100644
--- a/src/openrct2/object/ObjectRepository.cpp
+++ b/src/openrct2/object/ObjectRepository.cpp
@@ -166,6 +166,23 @@ protected:
                     stream->WriteValue<rct_object_entry>(entry);
                 }
                 break;
+            case ObjectType::SmallScenery:
+            case ObjectType::LargeScenery:
+            case ObjectType::Walls:
+            case ObjectType::Banners:
+            case ObjectType::Paths:
+            case ObjectType::PathBits:
+            case ObjectType::ParkEntrance:
+            case ObjectType::Water:
+            case ObjectType::ScenarioText:
+            case ObjectType::TerrainSurface:
+            case ObjectType::TerrainEdge:
+            case ObjectType::Station:
+            case ObjectType::Music:
+            case ObjectType::Count:
+            case ObjectType::None:
+                //Switch processes only ObjectType::Ride and ObjectType::SceneryGroup
+                break;
         }
     }
 
@@ -215,6 +232,23 @@ protected:
                 }
                 break;
             }
+            case ObjectType::SmallScenery:
+            case ObjectType::LargeScenery:
+            case ObjectType::Walls:
+            case ObjectType::Banners:
+            case ObjectType::Paths:
+            case ObjectType::PathBits:
+            case ObjectType::ParkEntrance:
+            case ObjectType::Water:
+            case ObjectType::ScenarioText:
+            case ObjectType::TerrainSurface:
+            case ObjectType::TerrainEdge:
+            case ObjectType::Station:
+            case ObjectType::Music:
+            case ObjectType::Count:
+            case ObjectType::None:
+                //Switch processes only ObjectType::Ride and ObjectType::SceneryGroup
+                break;
         }
         return item;
     }
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index e66cbf6bee..3c301f7d3d 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -529,7 +529,7 @@ private:
                 auto foundObject = objectRepository.FindObjectLegacy(objectName);
                 if (foundObject != nullptr)
                 {
-                    uint8_t objectType = foundObject->ObjectEntry.GetType();
+                    ObjectType objectType = foundObject->ObjectEntry.GetType();
                     switch (objectType)
                     {
                         case ObjectType::SmallScenery:
@@ -537,6 +537,7 @@ private:
                         case ObjectType::Walls:
                         case ObjectType::Paths:
                         case ObjectType::PathBits:
+                        {
                             EntryList* entries = GetEntryList(objectType);
 
                             // Check if there are spare entries available
@@ -546,6 +547,21 @@ private:
                                 entries->GetOrAddEntry(objectName);
                             }
                             break;
+                        }
+                        case ObjectType::Ride:
+                        case ObjectType::Banners:
+                        case ObjectType::SceneryGroup:
+                        case ObjectType::ParkEntrance:
+                        case ObjectType::Water:
+                        case ObjectType::ScenarioText:
+                        case ObjectType::TerrainSurface:
+                        case ObjectType::TerrainEdge:
+                        case ObjectType::Station:
+                        case ObjectType::Music:
+                        case ObjectType::Count:
+                        case ObjectType::None:
+                            //This switch processes only ObjectTypes valid for scenery
+                            break;
                     }
                 }
             }
@@ -1892,12 +1908,12 @@ private:
         LoadObjects(ObjectType::Water, _waterEntry);
     }
 
-    void LoadObjects(uint8_t objectType, const EntryList& entries)
+    void LoadObjects(ObjectType objectType, const EntryList& entries)
     {
         LoadObjects(objectType, entries.GetEntries());
     }
 
-    void LoadObjects(uint8_t objectType, const std::vector<const char*>& entries)
+    void LoadObjects(ObjectType objectType, const std::vector<const char*>& entries)
     {
         auto& objectManager = OpenRCT2::GetContext()->GetObjectManager();
 
@@ -1920,13 +1936,13 @@ private:
         }
     }
 
-    void AppendRequiredObjects(std::vector<rct_object_entry>& entries, uint8_t objectType, const EntryList& entryList)
+    void AppendRequiredObjects(std::vector<rct_object_entry>& entries, ObjectType objectType, const EntryList& entryList)
     {
         AppendRequiredObjects(entries, objectType, entryList.GetEntries());
     }
 
     void AppendRequiredObjects(
-        std::vector<rct_object_entry>& entries, uint8_t objectType, const std::vector<const char*>& objectNames)
+        std::vector<rct_object_entry>& entries, ObjectType objectType, const std::vector<const char*>& objectNames)
     {
         for (const auto objectName : objectNames)
         {
@@ -1966,7 +1982,7 @@ private:
     }
 
     void GetInvalidObjects(
-        uint8_t objectType, const std::vector<const char*>& entries, std::vector<rct_object_entry>& missingObjects)
+        ObjectType objectType, const std::vector<const char*>& entries, std::vector<rct_object_entry>& missingObjects)
     {
         auto& objectRepository = OpenRCT2::GetContext()->GetObjectRepository();
         for (const char* objectName : entries)
@@ -2954,7 +2970,7 @@ private:
         }
     }
 
-    EntryList* GetEntryList(uint8_t objectType)
+    EntryList* GetEntryList(ObjectType objectType)
     {
         switch (objectType)
         {
@@ -2974,6 +2990,17 @@ private:
                 return &_sceneryGroupEntries;
             case ObjectType::Water:
                 return &_waterEntry;
+            case ObjectType::Banners:
+            case ObjectType::ParkEntrance:
+            case ObjectType::ScenarioText:
+            case ObjectType::TerrainSurface:
+            case ObjectType::TerrainEdge:
+            case ObjectType::Station:
+            case ObjectType::Music:
+            case ObjectType::Count:
+            case ObjectType::None:
+                //This switch processes only ObjectType for for Entries
+                break;
         }
         return nullptr;
     }
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index f2f3fbb042..7dadfdecd7 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -1679,7 +1679,7 @@ public:
         std::memset(&nullEntry, 0xFF, sizeof(nullEntry));
 
         int objectIt = 0;
-        for (int16_t objectType = ObjectType::Ride; objectType <= ObjectType::Water; objectType++)
+        for (int16_t objectType = EnumValue(ObjectType::Ride); objectType <= EnumValue(ObjectType::Water); objectType++)
         {
             for (int16_t i = 0; i < rct2_object_entry_group_counts[objectType]; i++, objectIt++)
             {
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index bdbd855467..ec2d47183e 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -227,7 +227,7 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
 
 std::string_view get_ride_entry_name(ObjectEntryIndex index)
 {
-    if (index >= object_entry_group_counts[ObjectType::Ride])
+    if (index >= object_entry_group_counts[EnumValue(ObjectType::Ride)])
     {
         log_error("invalid index %d for ride type", index);
         return {};
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index ea962a3afd..d3b553a985 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -667,7 +667,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
 {
     for (auto& scenery : td6->scenery_elements)
     {
-        uint8_t entry_type{ 0 };
+        ObjectType entry_type{ 0 };
         ObjectEntryIndex entryIndex{ 0 };
         if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entryIndex))
         {
@@ -728,6 +728,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
                 break;
             }
             case ObjectType::SmallScenery:
+            {
                 scenery.y = -scenery.y;
 
                 if (scenery_small_entry_has_flag(scenery_entry, SMALL_SCENERY_FLAG_DIAGONAL))
@@ -746,16 +747,18 @@ static void track_design_mirror_scenery(TrackDesign* td6)
 
                 scenery.flags ^= (1 << 2);
                 break;
-
+            }
             case ObjectType::Walls:
+            {
                 scenery.y = -scenery.y;
                 if (scenery.flags & (1 << 0))
                 {
                     scenery.flags ^= (1 << 1);
                 }
                 break;
-
+            }
             case ObjectType::Paths:
+            {
                 scenery.y = -scenery.y;
 
                 if (scenery.flags & (1 << 5))
@@ -767,6 +770,23 @@ static void track_design_mirror_scenery(TrackDesign* td6)
                 flags = ((flags & (1 << 3)) >> 2) | ((flags & (1 << 1)) << 2);
                 scenery.flags &= 0xF5;
                 scenery.flags |= flags;
+                break;
+            }
+            case ObjectType::Ride:
+            case ObjectType::Banners:
+            case ObjectType::PathBits:
+            case ObjectType::SceneryGroup:
+            case ObjectType::ParkEntrance:
+            case ObjectType::Water:
+            case ObjectType::ScenarioText:
+            case ObjectType::TerrainSurface:
+            case ObjectType::TerrainEdge:
+            case ObjectType::Station:
+            case ObjectType::Music:
+            case ObjectType::Count:
+            case ObjectType::None:
+                //This switch processes only ObjectType for Scenery items.
+                break;
         }
     }
 }
@@ -862,7 +882,7 @@ static void track_design_update_max_min_coordinates(const CoordsXYZ& coords)
 }
 
 static bool TrackDesignPlaceSceneryElementGetEntry(
-    uint8_t& entry_type, ObjectEntryIndex& entry_index, const TrackDesignSceneryElement& scenery)
+    ObjectType& entry_type, ObjectEntryIndex& entry_index, const TrackDesignSceneryElement& scenery)
 {
     if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entry_index))
     {
@@ -893,7 +913,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
             }
         }
 
-        if (entry_index == object_entry_group_counts[ObjectType::Paths])
+        if (entry_index == object_entry_group_counts[EnumValue(ObjectType::Paths)])
         {
             _trackDesignPlaceStateSceneryUnavailable = true;
             return true;
@@ -905,7 +925,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
 static bool TrackDesignPlaceSceneryElementRemoveGhost(
     CoordsXY mapCoord, const TrackDesignSceneryElement& scenery, uint8_t rotation, int32_t originZ)
 {
-    uint8_t entry_type;
+    ObjectType entry_type;
     ObjectEntryIndex entry_index;
     if (TrackDesignPlaceSceneryElementGetEntry(entry_type, entry_index, scenery))
     {
@@ -997,7 +1017,7 @@ static bool TrackDesignPlaceSceneryElement(
         || _trackDesignPlaceOperation == PTD_OPERATION_PLACE_GHOST
         || _trackDesignPlaceOperation == PTD_OPERATION_PLACE_TRACK_PREVIEW)
     {
-        uint8_t entry_type;
+        ObjectType entry_type;
         ObjectEntryIndex entry_index;
         if (TrackDesignPlaceSceneryElementGetEntry(entry_type, entry_index, scenery))
         {
diff --git a/src/openrct2/scripting/ScContext.hpp b/src/openrct2/scripting/ScContext.hpp
index bb68387bc0..e75a4953fb 100644
--- a/src/openrct2/scripting/ScContext.hpp
+++ b/src/openrct2/scripting/ScContext.hpp
@@ -85,16 +85,16 @@ namespace OpenRCT2::Scripting
             }
         }
 
-        static DukValue CreateScObject(duk_context* ctx, uint8_t type, int32_t index)
+        static DukValue CreateScObject(duk_context* ctx, ObjectType type, int32_t index)
         {
             switch (type)
             {
                 case ObjectType::Ride:
-                    return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(type, index));
+                    return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(EnumValue(type), index));
                 case ObjectType::SmallScenery:
-                    return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(type, index));
+                    return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(EnumValue(type), index));
                 default:
-                    return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(type, index));
+                    return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(EnumValue(type), index));
             }
         }
 
diff --git a/src/openrct2/scripting/ScObject.hpp b/src/openrct2/scripting/ScObject.hpp
index d9ce0c62e2..bee2cebfbb 100644
--- a/src/openrct2/scripting/ScObject.hpp
+++ b/src/openrct2/scripting/ScObject.hpp
@@ -45,17 +45,17 @@ namespace OpenRCT2::Scripting
             dukglue_register_property(ctx, &ScObject::name_get, nullptr, "name");
         }
 
-        static std::optional<uint8_t> StringToObjectType(const std::string_view& type)
+        static std::optional<ObjectType> StringToObjectType(const std::string_view& type)
         {
-            for (uint8_t i = 0; i < ObjectType::Count; i++)
+            for (uint8_t i = 0; i < EnumValue(ObjectType::Count); i++)
             {
                 auto s = ObjectTypeToString(i);
                 if (s == type)
                 {
-                    return i;
+                    return static_cast<ObjectType>(i);
                 }
             }
-            return std::nullopt;
+            return ObjectType::None;
         }
 
         static std::string_view ObjectTypeToString(uint8_t type)
diff --git a/src/openrct2/scripting/ScRide.hpp b/src/openrct2/scripting/ScRide.hpp
index 33adccd4da..43bbadbc21 100644
--- a/src/openrct2/scripting/ScRide.hpp
+++ b/src/openrct2/scripting/ScRide.hpp
@@ -199,7 +199,7 @@ namespace OpenRCT2::Scripting
                 auto rideObject = GetContext()->GetObjectManager().GetLoadedObject(ObjectType::Ride, ride->subtype);
                 if (rideObject != nullptr)
                 {
-                    return std::make_shared<ScRideObject>(ObjectType::Ride, ride->subtype);
+                    return std::make_shared<ScRideObject>(EnumValue(ObjectType::Ride), ride->subtype);
                 }
             }
             return nullptr;
diff --git a/src/openrct2/world/MapGen.cpp b/src/openrct2/world/MapGen.cpp
index f6731bb1e5..0d39013ca0 100644
--- a/src/openrct2/world/MapGen.cpp
+++ b/src/openrct2/world/MapGen.cpp
@@ -260,7 +260,7 @@ static void mapgen_place_trees()
     std::vector<int32_t> desertTreeIds(std::size(DesertTrees), 0);
     std::vector<int32_t> snowTreeIds(std::size(SnowTrees), 0);
 
-    for (int32_t i = 0; i < object_entry_group_counts[ObjectType::SmallScenery]; i++)
+    for (int32_t i = 0; i < object_entry_group_counts[EnumValue(ObjectType::SmallScenery)]; i++)
     {
         auto sceneryEntry = get_small_scenery_entry(i);
         auto entry = object_entry_get_entry(ObjectType::SmallScenery, i);
diff --git a/test/testpaint/Compat.cpp b/test/testpaint/Compat.cpp
index 18935c2b05..edf92450e8 100644
--- a/test/testpaint/Compat.cpp
+++ b/test/testpaint/Compat.cpp
@@ -127,7 +127,7 @@ Ride* get_ride(ride_id_t index)
 
 rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
 {
-    if (index >= object_entry_group_counts[ObjectType::OBJECT_TYPE_RIDE])
+    if (index >= object_entry_group_counts[ObjectType::Ride])
     {
         log_error("invalid index %d for ride type", index);
         return nullptr;