diff --git a/CommonLibF4/cmake/sourcelist.cmake b/CommonLibF4/cmake/sourcelist.cmake
index 9a9dd61e..da677f4b 100644
--- a/CommonLibF4/cmake/sourcelist.cmake
+++ b/CommonLibF4/cmake/sourcelist.cmake
@@ -197,11 +197,24 @@ set(SOURCES
 	include/RE/Bethesda/Movement.h
 	include/RE/Bethesda/NavMesh.h
 	include/RE/Bethesda/NavMeshInfoMap.h
+	include/RE/Bethesda/PipboyArray.h
 	include/RE/Bethesda/PipboyDataGroup.h
+	include/RE/Bethesda/PipboyDataManager.h
 	include/RE/Bethesda/PipboyInventoryData.h
 	include/RE/Bethesda/PipboyInventoryUtils.h
+	include/RE/Bethesda/PipboyLogData.h
 	include/RE/Bethesda/PipboyManager.h
+	include/RE/Bethesda/PipboyMapData.h
+	include/RE/Bethesda/PipboyPerksData.h
+	include/RE/Bethesda/PipboyPlayerInfoData.h
+	include/RE/Bethesda/PipboyQuestData.h
+	include/RE/Bethesda/PipboyRadioData.h
+	include/RE/Bethesda/PipboySpecialData.h
+	include/RE/Bethesda/PipboyStatsData.h
+	include/RE/Bethesda/PipboyStatusData.h
+	include/RE/Bethesda/PipboyThrottleManager.h
 	include/RE/Bethesda/PipboyValue.h
+	include/RE/Bethesda/PipboyWorkshopData.h
 	include/RE/Bethesda/PlayerCharacter.h
 	include/RE/Bethesda/PlayerControls.h
 	include/RE/Bethesda/PowerArmor.h
diff --git a/CommonLibF4/include/RE/Bethesda/Actor.h b/CommonLibF4/include/RE/Bethesda/Actor.h
index 19818d37..1d038f89 100644
--- a/CommonLibF4/include/RE/Bethesda/Actor.h
+++ b/CommonLibF4/include/RE/Bethesda/Actor.h
@@ -20,9 +20,6 @@
 
 namespace RE
 {
-	enum class ACTOR_CRITICAL_STAGE;
-	enum class ACTOR_LIFE_STATE;
-	enum class ACTOR_LOS_LOCATION;
 	enum class ATTACK_STATE_ENUM;
 	enum class COMMAND_TYPE;
 	enum class DEFAULT_OBJECT;
@@ -112,6 +109,41 @@ namespace RE
 		struct PerkEntryUpdatedEvent;
 	}
 
+	enum class ACTOR_CRITICAL_STAGE : std::int32_t
+	{
+		kNone = 0,
+		kGooStart = 1,
+		kGooEnd = 2,
+		kDisintegrateStart = 3,
+		kDisintegrateEnd = 4,
+		kFreezeStart = 5,
+		kFreezeEnd = 6,
+		kCount = 7
+	};
+
+	enum class ACTOR_LIFE_STATE : std::int32_t
+	{
+		kAlive = 0,
+		kDying = 1,
+		kDead = 2,
+		kUnconscious = 3,
+		kReanimate = 4,
+		kRecycle = 5,
+		kRestrained = 6,
+		kEssentialDown = 7,
+		kBleedout = 8
+	};
+
+	enum class ACTOR_LOS_LOCATION : std::int32_t
+	{
+		kNone = 0,
+		kEye = 1,
+		kHead = 2,
+		kTorse = 3,
+		kFeet = 4,
+		kCount = 5
+	};
+
 	enum class PTYPE : std::int32_t
 	{
 		kExplore = 0,
diff --git a/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h b/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h
index df741814..107d5690 100644
--- a/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h
+++ b/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h
@@ -73,6 +73,13 @@ namespace RE
 			return func(this, a_handleID);
 		}
 
+		[[nodiscard]] bool ForceMergeStacks(const std::uint32_t& a_handleID)
+		{
+			using func_t = decltype(&BGSInventoryInterface::ForceMergeStacks);
+			static REL::Relocation<func_t> func{ REL::ID(2194032) };
+			return func(this, a_handleID);
+		}
+
 		// members
 		BSTArray<Agent> agentArray;  // B8
 	};
diff --git a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h
index 81ea008e..a624b3e6 100644
--- a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h
+++ b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h
@@ -80,6 +80,25 @@ namespace RE
 		};
 		static_assert(sizeof(CheckStackIDFunctor) == 0x10);
 
+		class alignas(0x08) CheckExtraDataFunctor :
+			public StackDataCompareFunctor // 00
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::BGSInventoryItem__CheckExtraDataFunctor };
+			static constexpr auto VTABLE{ VTABLE::BGSInventoryItem__CheckExtraDataFunctor };
+
+			CheckExtraDataFunctor(const BGSInventoryItem::Stack* a_stack) noexcept :
+				extra(a_stack->extra.get())
+			{}
+
+			// override (StackDataCompareFunctor)
+			bool CompareData(const BGSInventoryItem::Stack&) override { return this->extra == extra; }
+
+			// members
+			const ExtraDataList* extra;	// 08
+		};
+		static_assert(sizeof(CheckExtraDataFunctor) == 0x10);
+
 		class __declspec(novtable) alignas(0x08) StackDataWriteFunctor
 		{
 		public:
@@ -194,6 +213,13 @@ namespace RE
 			return func(this, a_index);
 		}
 
+		[[nodiscard]] void MergeStacks()
+		{
+			using func_t = decltype(&BGSInventoryItem::MergeStacks);
+			static REL::Relocation<func_t> func{ REL::ID(2194109) };
+			return func(this);
+		}
+
 		// members
 		TESBoundObject*        object;     // 00
 		BSTSmartPointer<Stack> stackData;  // 08
diff --git a/CommonLibF4/include/RE/Bethesda/BSExtraData.h b/CommonLibF4/include/RE/Bethesda/BSExtraData.h
index f674a758..556dd817 100644
--- a/CommonLibF4/include/RE/Bethesda/BSExtraData.h
+++ b/CommonLibF4/include/RE/Bethesda/BSExtraData.h
@@ -380,7 +380,105 @@ namespace RE
 	struct __declspec(novtable) MapMarkerData :
 		public TESFullName  // 00
 	{
-		std::uint32_t flags;  // 10
+		enum MARKER_TYPE : std::uint16_t
+		{
+			kCave = 0,
+			kCity,
+			kDiamondCity,
+			kEncampment,
+			kIndustrial,
+			kGovtBuilding,
+			kMetro,
+			kMilitaryBase,
+			kLandmark,
+			kOffice,
+			kRuinsTown,
+			kRuinsUrban,
+			kSanctuary,
+			kSettlement,
+			kSewer,
+			kVault,
+			kAirfield,
+			kBunkerHill,
+			kCamper,
+			kCar,
+			kChurch,
+			kCountryClub,
+			kCustomHouse,
+			kDriveIn,
+			kElevatedHighway,
+			kFaneuilHall,
+			kFarm,
+			kFillingStation,
+			kForest,
+			kGoodNeighbor,
+			kGraveyard,
+			kHospital,
+			kIndustrialDome,
+			kIndustrialStacks,
+			kInstitute,
+			kIrishPride,
+			kJunkyard,
+			kObservatory,
+			kPier,
+			kPondOrLake,
+			kQuarry,
+			kRadioactiveArea,
+			kRadioTower,
+			kSalem,
+			kSchool,
+			kShipwreck,
+			kSubmarine,
+			kSwanPond,
+			kSynthHead,
+			kTown,
+			kBOS,
+			kBrownstone,
+			kBunker,
+			kCastle,
+			kSkyscraper,
+			kLibertalia,
+			kLowrise,
+			kMinutemen,
+			kPoliceStation,
+			kPrydwen,
+			kRailroadFaction,
+			kRailroad,
+			kSatellite,
+			kSentinel,
+			kUSSConstitution,
+			kMechanist,
+			kRaiderSettlement,
+			kVassalSettlement,
+			kPotentialVassalSettlement,
+			kBottlingPlant,
+			kGalactic,
+			kHub,
+			kKiddieKingdom,
+			kMonorail,
+			kRides,
+			kSafari,
+			kWildWest,
+			kPOI,
+			kDisciples,
+			kOperators,
+			kPack,
+			kDoor,
+			kCountEditor,
+			kQuest,
+			kQuestDoor,
+			kQuestMultiple,
+			kPlayerSet,
+			kPlayerLocation,
+			kPowerArmorLocation,
+			kDogmeat,
+			kTeammate,
+			kCountTotal
+		};
+
+		std::uint8_t flags;				// 10
+		std::uint8_t originalFlags;		// 11
+		MARKER_TYPE type;               // 12
 	};
 	static_assert(sizeof(MapMarkerData) == 0x18);
 
diff --git a/CommonLibF4/include/RE/Bethesda/Events.h b/CommonLibF4/include/RE/Bethesda/Events.h
index c898d8b0..50fbf569 100644
--- a/CommonLibF4/include/RE/Bethesda/Events.h
+++ b/CommonLibF4/include/RE/Bethesda/Events.h
@@ -18,6 +18,7 @@ namespace RE
 	class TESObjectCELL;
 	class TESObjectREFR;
 	class VATSCommand;
+	class BGSInstancedQuestObjective;
 
 	struct InventoryUserUIInterfaceEntry;
 
@@ -35,10 +36,10 @@ namespace RE
 
 	namespace ActorEquipManagerEvent
 	{
-		enum class Type
+		enum class Type : std::int32_t
 		{
-			Equip = 0,
-			Unequip,
+			kEquip,
+			kUnequip
 		};
 
 		struct Event
@@ -54,10 +55,10 @@ namespace RE
 
 	namespace PerkValueEvents
 	{
-		enum class Type
+		enum class Type : std::int32_t
 		{
-			Add = 0,
-			Remove
+			kAdd,
+			kRemove
 		};
 
 		struct PerkValueChangedEvent
@@ -77,6 +78,140 @@ namespace RE
 		static_assert(sizeof(PerkEntryUpdatedEvent) == 0x10);
 	}
 
+	namespace PlayerCharacterQuestEvent
+	{
+		enum Type : std::int32_t
+		{
+			kAddObjective,
+			kUpdateObjective,
+			kRemoveQuest,
+			kRemoveQuestTarget,
+			kUpdateQuestTarget
+		};
+
+		struct Event
+		{
+			PlayerCharacterQuestEvent::Type changeType;		// 00
+			BGSInstancedQuestObjective* questObjective;		// 08
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+
+	struct TESTrackedStatsEvent
+	{
+		BSFixedString stat; // 00
+		std::int32_t value; // 08
+	};
+	static_assert(sizeof(TESTrackedStatsEvent) == 0x10);
+
+	namespace TESQuestEvent
+	{
+		enum Type : std::int32_t
+		{
+			kUpdateQuestActiveStatus,
+			kUpdateQuestEnableStatus,
+			kUpdateQuestStageChange,
+			kUpdateMiscQuestVisibility
+		};
+
+		struct Event
+		{
+			TESQuestEvent::Type changeType; // 00
+			TESQuest* quest;				// 08
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+
+	struct TESLocationClearedEvent
+	{
+		const BGSLocation* loc;	//00
+	};
+	static_assert(sizeof(TESLocationClearedEvent) == 0x8);
+
+	namespace PlayerLifeStateChanged
+	{
+		struct Event
+		{
+			ACTOR_LIFE_STATE lifeState;	// 00
+		};
+		static_assert(sizeof(Event) == 0x4);
+	}
+
+	namespace PlayerActiveEffectChanged
+	{
+		enum Status : std::int32_t
+		{
+			kAdded,
+			kRemoved,
+			kStatusChanged
+		};
+
+		struct Event
+		{
+			BSTSmartPointer<ActiveEffect, BSTSmartPointerIntrusiveRefCount> effect; // 00
+			PlayerActiveEffectChanged::Status status;								// 08
+		};
+	}
+
+	namespace HourPassed
+	{
+		// intentional
+		struct Event
+		{};
+	}
+
+	namespace LevelIncrease
+	{
+		struct Event
+		{
+			std::uint32_t newLevel;	// 00
+		};
+		static_assert(sizeof(Event) == 0x4);
+	}
+
+	namespace LoadingStatusChanged
+	{
+		struct Event
+		{
+			bool isLoading;	// 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+
+	namespace ActorItemEquipped
+	{
+		struct Event
+		{
+			const TESBoundObject* item;		// 00
+			const Actor*          equipper;	// 08
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+
+	namespace PlayerInDialogueChanged
+	{
+		struct Event
+		{
+			bool isPlayerInDialogue; // 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+
+	namespace LocationMarkerArrayUpdate
+	{
+		struct Event
+		{
+			bool shouldClearMapMarkers;	// 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+
+	namespace LocalMapCameraUpdate
+	{
+		// intentional
+		struct Event
+		{}; 
+	}
 	namespace HolotapeStateChanged
 	{
 		// intentional
@@ -84,6 +219,17 @@ namespace RE
 		{};
 	}
 
+	// intentional
+	struct PlayerUpdateEvent
+	{};
+
+	namespace CustomMarkerUpdate
+	{
+		// intentional
+		struct Event
+		{};
+	}
+
 	namespace BGSInventoryItemEvent
 	{
 		struct Event
@@ -97,8 +243,8 @@ namespace RE
 	{
 		struct ComponentFavoriteEvent
 		{
-			BGSComponent* component;	// 00
-			bool isFavorited;
+			BGSComponent* component; // 00
+			bool isFavorited; // 08
 		};
 		static_assert(sizeof(ComponentFavoriteEvent) == 0x10);
 	}
@@ -107,17 +253,29 @@ namespace RE
 	{
 		struct Event
 		{
-			std::uint32_t oldDifficulty;
-			std::uint32_t newDifficulty;
+			std::uint32_t oldDifficulty; // 00
+			std::uint32_t newDifficulty; // 04
 		};
 		static_assert(sizeof(Event) == 0x8);
 	}
 
+	namespace TravelMarkerStateChange
+	{
+		struct Event
+		{
+			BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21, 5>> markerRef;	// 00
+			MapMarkerData* data;														// 08
+			std::uint32_t selectedMarkerIndex;											// 10					
+			bool discovered;															// 14
+		};
+		static_assert(sizeof(Event) == 0x18);
+	}
+
 	struct BGSActorEvent
 	{
 	public:
 		// member
-		ActorHandle actor;  // 00
+		ActorHandle actor; // 00
 	};
 	static_assert(sizeof(BGSActorEvent) == 0x4);
 
@@ -126,8 +284,8 @@ namespace RE
 	public:
 		enum class CellFlag
 		{
-			kEnter = 0,
-			kLeave = 1
+			kEnter,
+			kLeave
 		};
 
 		// members
@@ -216,11 +374,12 @@ namespace RE
 			return *singleton;
 		}
 	};
+	static_assert(sizeof(CanDisplayNextHUDMessage) == 0x2);
 
 	struct CellAttachDetachEvent
 	{
 	public:
-		enum class EVENT_TYPE
+		enum class EVENT_TYPE : std::int32_t
 		{
 			kPreAttach,
 			kPostAttach,
@@ -269,7 +428,7 @@ namespace RE
 			return *singleton;
 		}
 	};
-	static_assert(sizeof(CurrentRadiationSourceCount) == 0x08);
+	static_assert(sizeof(CurrentRadiationSourceCount) == 0x8);
 
 	struct ColorUpdateEvent
 	{
@@ -293,14 +452,14 @@ namespace RE
 	{
 	public:
 	};
-	static_assert(sizeof(CurrentRadsDisplayMagnitude) == 0x08);
+	static_assert(sizeof(CurrentRadsDisplayMagnitude) == 0x8);
 
 	class CurrentRadsPercentOfLethal :
 		public BSTValueEvent<float>
 	{
 	public:
 	};
-	static_assert(sizeof(CurrentRadsPercentOfLethal) == 0x08);
+	static_assert(sizeof(CurrentRadsPercentOfLethal) == 0x8);
 
 	struct DoBeforeNewOrLoadCompletedEvent
 	{
@@ -317,7 +476,7 @@ namespace RE
 			return *singleton;
 		}
 	};
-	static_assert(sizeof(DoBeforeNewOrLoadCompletedEvent) == 0x01);
+	static_assert(sizeof(DoBeforeNewOrLoadCompletedEvent) == 0x1);
 
 	struct HUDModeEvent
 	{
@@ -335,9 +494,9 @@ namespace RE
 		}
 
 		// members
-		const BSTArray<HUDModeType>* currentHUDModes;
+		const BSTArray<HUDModeType>* currentHUDModes; // 00
 	};
-	static_assert(sizeof(HUDModeEvent) == 0x08);
+	static_assert(sizeof(HUDModeEvent) == 0x8);
 
 	struct InventoryItemDisplayData
 	{
@@ -468,7 +627,7 @@ namespace RE
 			return *singleton;
 		}
 	};
-	static_assert(sizeof(PipboyLightEvent) == 0x02);
+	static_assert(sizeof(PipboyLightEvent) == 0x2);
 
 	struct PlayerAmmoCounts
 	{
@@ -477,21 +636,21 @@ namespace RE
 		std::uint32_t clipAmmo;     // 00
 		std::uint32_t reserveAmmo;  // 04
 	};
-	static_assert(sizeof(PlayerAmmoCounts) == 0x08);
+	static_assert(sizeof(PlayerAmmoCounts) == 0x8);
 
 	class PlayerAmmoCountEvent :
 		public BSTValueEvent<PlayerAmmoCounts>
 	{
 	public:
 	};
-	static_assert(sizeof(PlayerAmmoCountEvent) == 0x0C);
+	static_assert(sizeof(PlayerAmmoCountEvent) == 0xC);
 
 	class PlayerWeaponReloadEvent :
 		public BSTValueEvent<bool>
 	{
 	public:
 	};
-	static_assert(sizeof(PlayerWeaponReloadEvent) == 0x02);
+	static_assert(sizeof(PlayerWeaponReloadEvent) == 0x2);
 
 	struct PowerArmorLightData
 	{
@@ -511,7 +670,7 @@ namespace RE
 		// members
 		bool lightOn;  // 00
 	};
-	static_assert(sizeof(PowerArmorLightData) == 0x01);
+	static_assert(sizeof(PowerArmorLightData) == 0x1);
 
 	struct QuickContainerStateData
 	{
@@ -547,11 +706,11 @@ namespace RE
 	{
 	public:
 		// members
-		BSFixedString                 SwfName;
-		const BGSSoundDescriptorForm* soundForm;
-		bool                          VATSCritAppliedAnim;
-		bool                          VATSCritFillenAnim;
-		bool                          dialogueSpeechChallengeAnim;
+		BSFixedString                 SwfName;						// 00
+		const BGSSoundDescriptorForm* soundForm;					// 08
+		bool                          VATSCritAppliedAnim;			// 10
+		bool                          VATSCritFillenAnim;			// 11
+		bool                          dialogueSpeechChallengeAnim;	// 12
 	};
 	static_assert(sizeof(HUDPerkVaultBoyData) == 0x18);
 
@@ -898,20 +1057,20 @@ namespace RE
 
 	struct PositionPlayerEvent
 	{
-		enum EVENT_TYPE : uint32_t
+		enum EVENT_TYPE : std::int32_t
 		{
-			PRE_POSITION_PLAYER = 0x0,
-			POSITION_PLAYER_PRE_UPDATE_PACKAGES = 0x1,
-			POSITION_PLAYER_POST_UPDATE_PACKAGES = 0x2,
-			POST_POSITION_PLAYER = 0x3,
-			FINISH_POSITION_PLAYER = 0x4,
+			kPrePositionPlayer,
+			kPositionPlayerPreUpdatePackages,
+			kPositionPlayerPostUpdatePackages,
+			kPostPositionPlayer,
+			kFinishPositionPlayer,
 		};
 
 		// members
-		EVENT_TYPE type;
-		bool       NoLoadScreen;
+		EVENT_TYPE type;			// 00
+		bool       NoLoadScreen;	// 04
 	};
-	static_assert(sizeof(PositionPlayerEvent) == 0x08);
+	static_assert(sizeof(PositionPlayerEvent) == 0x8);
 
 	class TESInitScriptEvent
 	{
@@ -919,7 +1078,7 @@ namespace RE
 		// Members
 		TESObjectREFR* hObjectInitialized;  // 00
 	};
-	static_assert(sizeof(TESInitScriptEvent) == 0x08);
+	static_assert(sizeof(TESInitScriptEvent) == 0x8);
 
 	class TESInitScriptEventSource : public BSTEventSource<TESInitScriptEvent>
 	{
diff --git a/CommonLibF4/include/RE/Bethesda/IMenu.h b/CommonLibF4/include/RE/Bethesda/IMenu.h
index 6a904765..cb20a6cf 100644
--- a/CommonLibF4/include/RE/Bethesda/IMenu.h
+++ b/CommonLibF4/include/RE/Bethesda/IMenu.h
@@ -1212,7 +1212,7 @@ namespace RE
 		void UpdateData() override
 		{
 			using func_t = decltype(&PipboyInventoryMenu::UpdateData);
-			static REL::Relocation<func_t> func{ REL::ID(762897) };
+			static REL::Relocation<func_t> func{ REL::ID(2224143) };
 			return func(this);
 		}
 	};
@@ -1744,6 +1744,13 @@ namespace RE
 		virtual void                 ShowBuildFailureMessage();                    // 1A
 		virtual bool                 TryCreate() = 0;                              // 1B
 
+		void UpdateOptimizedAutoBuildInv()
+		{
+			using func_t = decltype(&WorkbenchMenuBase::UpdateOptimizedAutoBuildInv);
+			static REL::Relocation<func_t> func{ REL::ID(2224955) };
+			return func(this);
+		}
+
 		// members
 		NiPointer<TESObjectREFR>                   sharedContainerRef;        // 0E0
 		NiPointer<TESObjectREFR>                   workbenchContainerRef;     // 0E8
@@ -1860,6 +1867,30 @@ namespace RE
 		};
 		static_assert(sizeof(InitDataScrap) == 0x40);
 
+		class __declspec(novtable) InitDataRepairFailure :
+			public InitData  // 00
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__InitDataRepairFailure };
+			static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__InitDataRepairFailure };
+
+			InitDataRepairFailure(const BSTArray<BSTTuple<TESForm*, BGSTypedFormValuePair::SharedVal>>* requiredItems) :
+				InitData(GameSettingCollection::GetSingleton()->GetSetting("sCannotRepairMessage")->GetString(), "$OK", CONFIRM_TYPE::kRepairFailure),
+				requiredItems(requiredItems)
+			{
+				stl::emplace_vtable(this);
+			}
+
+			virtual ~InitDataRepairFailure() = default;  // 00
+
+			F4_HEAP_REDEFINE_NEW(InitDataRepairFailure);
+
+			// members
+			const BSTArray<BSTTuple<TESForm *,BGSTypedFormValuePair::SharedVal>>* requiredItems;  // 20
+			BSTHashMap<TESBoundObject*, std::uint32_t> availableComponents;						  // 28
+		};
+		static_assert(sizeof(InitDataRepairFailure) == 0x58);
+
 		// members
 		Scaleform::GFx::Value confirmObj;  // E0
 	};
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyArray.h b/CommonLibF4/include/RE/Bethesda/PipboyArray.h
new file mode 100644
index 00000000..dae0cb6e
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyArray.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyValue.h"
+
+namespace RE
+{
+	class PipboyArray :
+		public PipboyValue
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyArray };
+		static constexpr auto VTABLE{ VTABLE::PipboyArray };
+
+		// members
+		BSTArray<PipboyValue*> elements;			// 18
+		BSTSet<std::uint32_t> addedElementIDs;		// 30
+		BSTArray<std::uint32_t> removedElementIDs;	// 60
+		bool                   newlyCreated;		// 78
+	};
+	static_assert(sizeof(PipboyArray) == 0x80);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h b/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h
index 8f8759da..15e4bf0d 100644
--- a/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h
+++ b/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h
@@ -3,11 +3,10 @@
 #include "RE/Bethesda/BSTEvent.h"
 #include "RE/Bethesda/IMenu.h"
 #include "RE/Bethesda/PipboyValue.h"
+#include "RE/Bethesda/PipboyThrottleManager.h"
 
 namespace RE
 {
-	class PipboyThrottleManager;
-
 	class PipboyDataGroup :
 		public BSTEventSource<PipboyValueChangedEvent>  // 00
 	{
@@ -15,7 +14,7 @@ namespace RE
 		static constexpr auto RTTI{ RTTI::PipboyDataGroup };
 		static constexpr auto VTABLE{ VTABLE::PipboyDataGroup };
 
-		virtual ~PipboyDataGroup();  // 00
+		virtual ~PipboyDataGroup() = default;  // 00
 
 		// override
 		virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource<PipboyValueChangedEvent>* a_source);  // 01
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h b/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h
new file mode 100644
index 00000000..5864f6cf
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "RE/Bethesda/BSTSingleton.h"
+
+#include "RE/Bethesda/PipboyDataGroup.h"
+#include "RE/Bethesda/PipboyInventoryData.h"
+#include "RE/Bethesda/PipboyLogData.h"
+#include "RE/Bethesda/PipboyMapData.h"
+#include "RE/Bethesda/PipboyPerksData.h"
+#include "RE/Bethesda/PipboyPlayerInfoData.h"
+#include "RE/Bethesda/PipboyQuestData.h"
+#include "RE/Bethesda/PipboyRadioData.h"
+#include "RE/Bethesda/PipboySpecialData.h"
+#include "RE/Bethesda/PipboyThrottleManager.h"
+#include "RE/Bethesda/PipboyValue.h"
+#include "RE/Bethesda/PipboyWorkshopData.h"
+
+namespace RE
+{
+	class _declspec(novtable) PipboyDataManager :
+		public BSTSingletonSDM<PipboyDataManager>
+	{
+	public:
+		[[nodiscard]] static PipboyDataManager* GetSingleton()
+		{
+			static REL::Relocation<PipboyDataManager**> singleton{ REL::ID(2689086) };
+			return *singleton;
+		}
+
+		// members
+		PipboyObject rootObject;					// 08
+		PipboyStatsData statsData;                  // A0 
+		PipboySpecialData specialData;              // 1D8
+		PipboyPerksData perksData;                  // 280
+		PipboyInventoryData inventoryData;			// 358
+		PipboyQuestData questData;					// 4F0
+		PipboyWorkshopData workshopData;			// 5D8
+		PipboyLogData logData;						// 718
+		PipboyMapData mapData;                      // 7F0
+		PipboyRadioData radioData;					// A28
+		PipboyPlayerInfoData playerInfoData;        // AD8
+		PipboyStatusData statusData;				// BE0
+		PipboyDataGroup* dataGroups[11];			// CC0
+		PipboyThrottleManager throttleManager;		// D18
+	};
+	static_assert(sizeof(PipboyDataManager) == 0xD48);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h b/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h
index e30d8ac3..0dd02583 100644
--- a/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h
+++ b/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h
@@ -2,14 +2,14 @@
 
 #include "RE/Bethesda/BGSInventoryInterface.h"
 #include "RE/Bethesda/BSTArray.h"
+#include "RE/Bethesda/BSTEvent.h"
 #include "RE/Bethesda/BSTHashMap.h"
 #include "RE/Bethesda/BSTList.h"
+#include "RE/Bethesda/Events.h"
 #include "RE/Bethesda/PipboyDataGroup.h"
 
 namespace RE
 {
-	class PipboyDataGroup;
-
 	class PipboyInventoryData :
 		public PipboyDataGroup,												// 00
 		public BSTEventSink<BGSInventoryListEvent::Event>,					// 98
@@ -24,6 +24,11 @@ namespace RE
 		public BSTEventSink<PlayerDifficultySettingChanged::Event>			// E0
 	{
 	public:
+		static constexpr auto RTTI{ RTTI::PipboyInventoryData };
+		static constexpr auto VTABLE{ VTABLE::PipboyInventoryData };
+
+		virtual ~PipboyInventoryData();
+
 		enum ENTRY_TYPE
 		{
 			ENTRY_INT = 0,
@@ -55,6 +60,32 @@ namespace RE
 		};
 		static_assert(sizeof(ItemEntry) == 0x8);
 
+		// override
+		virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource<PipboyValueChangedEvent>* a_source);  // 01
+
+		// add
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);								// 02
+		virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource<ActorEquipManagerEvent::Event>* a_source);							// 03
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);		// 04
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource<PerkValueEvents::PerkEntryUpdatedEvent>* a_source);			// 05
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource<PerkValueEvents::PerkValueChangedEvent>* a_source);			// 06
+		virtual BSEventNotifyControl ProcessEvent(const InventoryInterface::FavoriteChangedEvent& a_event, BSTEventSource<InventoryInterface::FavoriteChangedEvent>* a_source);		// 07
+		virtual BSEventNotifyControl ProcessEvent(const HolotapeStateChanged::Event& a_event, BSTEventSource<HolotapeStateChanged::Event>* a_source);								// 08
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource<BGSInventoryItemEvent::Event>* a_source);								// 09
+		virtual BSEventNotifyControl ProcessEvent(const FavoriteMgr_Events::ComponentFavoriteEvent& a_event, BSTEventSource<FavoriteMgr_Events::ComponentFavoriteEvent>* a_source); // 0A
+		virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource<PlayerDifficultySettingChanged::Event>* a_source);			// 0B
+
+		virtual void Populate(bool a_arg1);		// 0C
+		virtual void DoClearData();				// 0D
+		virtual void DoClearSink();				// 0E
+
+		void RepopulateItemCardsOnSection(ENUM_FORM_ID itemTypeID)
+		{
+			using func_t = decltype(&PipboyInventoryData::RepopulateItemCardsOnSection);
+			static REL::Relocation<func_t> func{ REL::ID(2225279) };
+			return func(this, itemTypeID);
+		}
+
 		// members
 		PipboyObject* inventoryObject;											// E8
 		BSTHashMap<std::uint32_t, PipboyInventoryData::ItemEntry> itemEntries;	// F0
@@ -62,4 +93,5 @@ namespace RE
 		BSTArray<PipboyObject*> sortedItems;									// 150
 		BSTSet<ENUM_FORM_ID> queuedRepopulateCategories;						// 168
 	};
+	static_assert(sizeof(PipboyInventoryData) == 0x198);
 }
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyLogData.h b/CommonLibF4/include/RE/Bethesda/PipboyLogData.h
new file mode 100644
index 00000000..de5e21e7
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyLogData.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyArray.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyLogData :
+		public PipboyDataGroup,						// 00
+		public BSTEventSink<TESTrackedStatsEvent>	// 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyLogData };
+		static constexpr auto VTABLE{ VTABLE::PipboyLogData };
+
+		virtual ~PipboyLogData() = default; // 00
+
+		virtual BSEventNotifyControl ProcessEvent(const TESTrackedStatsEvent& a_event, BSTEventSource<TESTrackedStatsEvent>* a_source);								// 01
+
+		virtual void Populate(bool a_arg1) override;  // 02
+		virtual void DoClearData() override;          // 03
+		virtual void DoClearSink() override;          // 04
+
+		// members
+		PipboyArray* statTypeArray;								// A0
+		BSTHashMap<BSFixedString, PipboyObject*> statMap;		// A8
+	};
+	static_assert(sizeof(PipboyLogData) == 0xD8);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyMapData.h b/CommonLibF4/include/RE/Bethesda/PipboyMapData.h
new file mode 100644
index 00000000..c8fe0eff
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyMapData.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include "RE/Bethesda/BSTHashMap.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyMapData :
+		public PipboyDataGroup,											// 00
+		public BSTEventSink<TravelMarkerStateChange::Event>,			// 98
+		public BSTEventSink<PlayerUpdateEvent>,							// A0
+		public BSTEventSink<BGSActorCellEvent>,							// A8
+		public BSTEventSink<TESQuestEvent::Event>,						// B0
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,			// B8
+		public BSTEventSink<CustomMarkerUpdate::Event>,					// C0
+		public BSTEventSink<LocationMarkerArrayUpdate::Event>,			// C8
+		public BSTEventSink<LocalMapCameraUpdate::Event>,				// D0
+		public BSTEventSink<TESLocationClearedEvent>,					// D8
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>	// E0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyMapData };
+		static constexpr auto VTABLE{ VTABLE::PipboyMapData };
+
+		virtual ~PipboyMapData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const TravelMarkerStateChange::Event& a_event, BSTEventSource<TravelMarkerStateChange::Event>* a_source);						// 01
+		virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource<PlayerUpdateEvent>* a_source);												// 02
+		virtual BSEventNotifyControl ProcessEvent(const BGSActorCellEvent& a_event, BSTEventSource<BGSActorCellEvent>* a_source);												// 03
+		virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource<TESQuestEvent::Event>* a_source);											// 04
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);					// 05
+		virtual BSEventNotifyControl ProcessEvent(const CustomMarkerUpdate::Event& a_event, BSTEventSource<CustomMarkerUpdate::Event>* a_source);								// 06
+		virtual BSEventNotifyControl ProcessEvent(const LocationMarkerArrayUpdate::Event& a_event, BSTEventSource<LocationMarkerArrayUpdate::Event>* a_source);					// 07
+		virtual BSEventNotifyControl ProcessEvent(const LocalMapCameraUpdate::Event& a_event, BSTEventSource<LocalMapCameraUpdate::Event>* a_source);							// 08
+		virtual BSEventNotifyControl ProcessEvent(const TESLocationClearedEvent& a_event, BSTEventSource<TESLocationClearedEvent>* a_source);									// 09
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);	// 0A
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 0B
+		virtual void DoClearData() override;          // 0C
+		virtual void DoClearSink() override;          // 0D
+
+		// members
+		PipboyObject*																				mapObject;						// E8
+		BSTHashMap<const MapMarkerData*, PipboyObject*>												travelLocationsMarkers;			// F0
+		BSTHashMap<std::uint32_t, BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21,5>>>		travelLocationRefrHandles;		// 120
+		BSTArray<PipboyObject*>																		doorMarkers;					// 150
+		BSTArray<BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21, 5>>>						doorRefHandles;					// 168
+		BSTHashMap<BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21, 5>>, PipboyObject*>	localQuestMarkers;				// 180
+		BSTHashMap<BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21, 5>>, PipboyObject*>	worldQuestMarkers;				// 1B0
+		NiPoint3																					playerLastLocationPosition;		// 1E0
+		NiPoint3																					playerLastWorldPosition;		// 1EC
+		PipboyObject*																				localPlayerMarker;				// 1F8
+		PipboyObject*																				worldPlayerMarker;				// 200
+		PipboyObject*																				localCustomMarker;				// 208
+		PipboyObject*																				worldCustomMarker;				// 210
+		PipboyObject*																				localPowerArmorMarker;			// 218
+		PipboyObject*																				worldPowerArmorMarker;			// 220
+		PipboyObject*																				worldMapExtents;				// 230
+		PipboyObject*																				localMapExtents;				// 238
+	};
+	static_assert(sizeof(PipboyMapData) == 0x238);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h b/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h
new file mode 100644
index 00000000..fc48aea4
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyArray.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyPerksData :
+		public PipboyDataGroup,											// 00
+		public BSTEventSink<PerkValueEvents::PerkValueChangedEvent>		// 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPerksData };
+		static constexpr auto VTABLE{ VTABLE::PipboyPerksData };
+
+		virtual ~PipboyPerksData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource<PerkValueEvents::PerkValueChangedEvent>* a_source);  // 01
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 02
+		virtual void DoClearData() override;          // 03
+		virtual void DoClearSink() override;          // 04
+
+		PipboyArray* perkChains;					// A0
+		BSTArray<const BGSPerk*> perkChainRoots;	// A8
+		BSTArray<PipboyObject*>  perksArray;		// C0
+	};
+	static_assert(sizeof(PipboyPerksData) == 0xD8);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h b/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h
new file mode 100644
index 00000000..b6e6a3f9
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyPlayerInfoData :
+		public PipboyDataGroup,											// 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,	// 98
+		public BSTEventSink<BGSInventoryListEvent::Event>,				// A0
+		public BSTEventSink<ActorEquipManagerEvent::Event>,				// A8
+		public BSTEventSink<LevelIncrease::Event>,						// B0
+		public BSTEventSink<PerkPointIncreaseEvent>,					// B8
+		public BSTEventSink<PerkValueEvents::PerkEntryUpdatedEvent>,	// C0
+		public BSTEventSink<HourPassed::Event>,							// C8
+		public BSTEventSink<SPECIALMenuEvent::NameChangedEvent>,		// D0
+		public BSTEventSink<PlayerUpdateEvent>,							// D8
+		public BSTEventSink<BGSInventoryItemEvent::Event>,				// E0
+		public BSTEventSink<PlayerActiveEffectChanged::Event>,			// E8
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,			// F0
+		public BSTEventSink<PlayerDifficultySettingChanged::Event>		// F8
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPlayerInfoData };
+		static constexpr auto VTABLE{ VTABLE::PipboyPlayerInfoData };
+
+		virtual ~PipboyPlayerInfoData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);	// 01
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);							// 02
+		virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource<ActorEquipManagerEvent::Event>* a_source);                       // 03
+		virtual BSEventNotifyControl ProcessEvent(const LevelIncrease::Event& a_event, BSTEventSource<LevelIncrease::Event>* a_source);											// 04
+		virtual BSEventNotifyControl ProcessEvent(const PerkPointIncreaseEvent& a_event, BSTEventSource<PerkPointIncreaseEvent>* a_source);                                     // 05
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource<PerkValueEvents::PerkEntryUpdatedEvent>* a_source);		// 06
+		virtual BSEventNotifyControl ProcessEvent(const HourPassed::Event& a_event, BSTEventSource<HourPassed::Event>* a_source);                                               // 07
+		virtual BSEventNotifyControl ProcessEvent(const SPECIALMenuEvent::NameChangedEvent& a_event, BSTEventSource<SPECIALMenuEvent::NameChangedEvent>* a_source);				// 08
+		virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource<PlayerUpdateEvent>* a_source);                                               // 09
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource<BGSInventoryItemEvent::Event>* a_source);							// 0A
+		virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource<PlayerActiveEffectChanged::Event>* a_source);                 // 0B
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);					// 0C
+		virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource<PlayerDifficultySettingChanged::Event>* a_source);       // 0D
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 0E
+		virtual void DoClearData() override;          // 0F
+		virtual void DoClearSink() override;          // 10
+
+		// members
+		PipboyObject* playerInfoObject;
+	};
+	static_assert(sizeof(PipboyPlayerInfoData) == 0x108);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h b/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h
new file mode 100644
index 00000000..10cc67b0
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyArray.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyQuestData :
+		public PipboyDataGroup,										// 00
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,		// 89
+		public BSTEventSink<TESQuestEvent::Event>					// A0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyQuestData };
+		static constexpr auto VTABLE{ VTABLE::PipboyQuestData };
+
+		virtual ~PipboyQuestData();
+
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);		// 01
+		virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource<TESQuestEvent::Event>* a_source);								// 02
+
+		virtual void Populate(bool a_arg1) override;		// 03
+		virtual void DoClearData() override;          // 04
+		virtual void DoClearSink() override;                // 05
+
+		// members
+		std::uint32_t sortIndex;																					// A8
+		PipboyArray* questArray;																					// B0
+		//BSTHashMap<BSTTuple<TESQuest*, std::uint64_t>, BSTArray<BGSInstancedQuestObjective>*> objectivesByQuest;	// B8
+		void* unk[6];
+	};
+	static_assert(sizeof(PipboyQuestData) == 0xE8);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h b/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h
new file mode 100644
index 00000000..6993383e
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyArray.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace RadioManager
+	{
+		struct PipboyFrequencyDetectionEvent;
+		struct PipboyRadioTuningEvent;
+	}
+
+	class __declspec(novtable) PipboyRadioData :
+		public PipboyDataGroup,												// 00
+		public BSTEventSink<RadioManager::PipboyFrequencyDetectionEvent>,	// 98
+		public BSTEventSink<RadioManager::PipboyRadioTuningEvent>			// A0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyRadioData };
+		static constexpr auto VTABLE{ VTABLE::PipboyRadioData };
+
+		virtual ~PipboyRadioData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyFrequencyDetectionEvent& a_event, BSTEventSource<RadioManager::PipboyFrequencyDetectionEvent>* a_source);	// 01
+		virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyRadioTuningEvent& a_event, BSTEventSource<RadioManager::PipboyRadioTuningEvent>* a_source);					// 02
+
+		virtual void Populate(bool a_arg1) override;	// 03
+		virtual void DoClearData() override;			// 04
+		virtual void DoClearSink() override;            // 05
+
+		// members
+		PipboyArray* radioStations;				// A8
+	};
+	static_assert(sizeof(PipboyRadioData) == 0xB0);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h b/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h
new file mode 100644
index 00000000..389628d9
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyArray.h"
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboySpecialData :
+		public PipboyDataGroup,											// 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>	// 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboySpecialData };
+		static constexpr auto VTABLE{ VTABLE::PipboySpecialData };
+
+		virtual ~PipboySpecialData();
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 01
+		virtual void DoClearData() override;          // 02
+		virtual void DoClearSink() override;          // 03
+
+		// add
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source); // 04
+
+		// members
+		PipboyArray* specialsArray;	// A0
+	};
+	static_assert(sizeof(PipboySpecialData) == 0xA8);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h b/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h
new file mode 100644
index 00000000..e2a2d0d3
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	struct ConditionBoyEvent
+		{};
+
+	class __declspec(novtable) PipboyStatsData :
+		public PipboyDataGroup,											// 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,  // 98
+		public BSTEventSink<BGSInventoryListEvent::Event>,				// A0
+		public BSTEventSink<PlayerActiveEffectChanged::Event>,			// A8
+		public BSTEventSink<ConditionBoyEvent>,							// B0
+		public BSTEventSink<ActorItemEquipped::Event>,					// B8
+		public BSTEventSink<BGSInventoryItemEvent::Event>				// C0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyStatsData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatsData };
+
+		virtual ~PipboyStatsData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);							 // 02
+		virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource<PlayerActiveEffectChanged::Event>* a_source);                  // 03
+		virtual BSEventNotifyControl ProcessEvent(const ConditionBoyEvent& a_event, BSTEventSource<ConditionBoyEvent>* a_source);												 // 04
+		virtual BSEventNotifyControl ProcessEvent(const ActorItemEquipped::Event& a_event, BSTEventSource<ActorItemEquipped::Event>* a_source);                                  // 05
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);							 // 06
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 07
+		virtual void DoClearData() override;          // 08
+		virtual void DoClearSink() override;          // 09
+
+		// members
+		PipboyObject*																			   playerStatsObject;      // C8
+		PipboyArray*																			   activeEffectsArray;     // D0
+		BSTHashMap<MagicItem*, PipboyObject*>													   activeEffectsMap;	   // D8
+		BSTHashMap<BSTSmartPointer<ActiveEffect, BSTSmartPointerIntrusiveRefCount>, PipboyObject*> activeEffectEntriesMap; // 108
+	};
+	static_assert(sizeof(PipboyStatsData) == 0x138);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h b/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h
new file mode 100644
index 00000000..74adbce9
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyDataGroup.h"
+#include "RE/Bethesda/VATS.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyStatusData :
+		public PipboyDataGroup,									// 00
+		public BSTEventSink<PlayerLifeStateChanged::Event>,		// 98
+		public BSTEventSink<PlayerInDialogueChanged::Event>,	// A0
+		public BSTEventSink<MenuOpenCloseEvent>,				// A8
+		public BSTEventSink<BGSInventoryListEvent::Event>,		// B0
+		public BSTEventSink<LoadingStatusChanged::Event>,		// B8
+		public BSTEventSink<VATSEvents::ModeChange>,			// C0
+		public BSTEventSink<UserEventEnabledEvent>				// C8
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyStatusData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatusData };
+
+		virtual ~PipboyStatusData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const PlayerLifeStateChanged::Event& a_event, BSTEventSource<PlayerLifeStateChanged::Event>* a_source);    // 01
+		virtual BSEventNotifyControl ProcessEvent(const PlayerInDialogueChanged::Event& a_event, BSTEventSource<PlayerInDialogueChanged::Event>* a_source);  // 02
+		virtual BSEventNotifyControl ProcessEvent(const MenuOpenCloseEvent& a_event, BSTEventSource<MenuOpenCloseEvent>* a_source);                          // 03
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);      // 04
+		virtual BSEventNotifyControl ProcessEvent(const LoadingStatusChanged::Event& a_event, BSTEventSource<LoadingStatusChanged::Event>* a_source);        // 05
+		virtual BSEventNotifyControl ProcessEvent(const VATSEvents::ModeChange& a_event, BSTEventSource<VATSEvents::ModeChange>* a_source);                  // 06
+		virtual BSEventNotifyControl ProcessEvent(const UserEventEnabledEvent& a_event, BSTEventSource<UserEventEnabledEvent>* a_source);                    // 07
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 08
+		virtual void DoClearData() override;          // 09
+		virtual void DoClearSink() override;          // 0A
+
+		// members
+		PipboyObject* statusObject;
+		PipboyArray*  pipboyEffectColorArray;
+	};
+	static_assert(sizeof(PipboyStatusData) == 0xE0);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h b/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h
new file mode 100644
index 00000000..94d3598e
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/Bethesda/BSTHashMap.h"
+
+namespace RE
+{
+	class IPipboyThrottledValue
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IPipboyThrottledValue };
+		static constexpr auto VTABLE{ VTABLE::IPipboyThrottledValue };
+
+		// members
+		virtual ~IPipboyThrottledValue();	// 00
+
+		// add
+		void* Update();						// 01
+	};
+	static_assert(sizeof(IPipboyThrottledValue) == 0x8);
+
+	class PipboyThrottleManager
+	{
+		BSTHashMap<std::uint32_t, IPipboyThrottledValue*> valueMap;
+	};
+	static_assert(sizeof(PipboyThrottleManager) == 0x30);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h b/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h
new file mode 100644
index 00000000..dbabc664
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RE/Bethesda/PipboyDataGroup.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyWorkshopData :
+		public PipboyDataGroup,
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,
+		public BSTEventSink<Workshop::WorkshopModeEvent>
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyWorkshopData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatusData };
+
+		virtual ~PipboyWorkshopData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const Workshop::WorkshopModeEvent& a_event, BSTEventSource<Workshop::WorkshopModeEvent>* a_source);                            // 02
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 03
+		virtual void DoClearData() override;          // 04
+		virtual void DoClearSink() override;          // 05
+
+		// members
+		PipboyArray* workshopArray;
+		BSTHashMap<std::uint32_t, PipboyObject*> workshopMap;
+		BSTHashMap<BSFixedStringCS, std::int32_t> ratingUpdateFunctions;
+		BSTHashMap<BSFixedStringCS, std::uint32_t> getValueFunctions;
+	};
+	static_assert(sizeof(PipboyWorkshopData) == 0x140);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
index 1eed479a..98420cac 100644
--- a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
+++ b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
@@ -244,14 +244,14 @@ namespace RE
 			void ctor(bool a_suppressMessages, bool a_suppressAudio)
 			{
 				using func_t = decltype(&ScopedInventoryChangeMessageContext::ctor);
-				static REL::Relocation<func_t> func{ REL::ID(1512872) };
+				static REL::Relocation<func_t> func{ REL::ID(2233292) };
 				return func(this, a_suppressMessages, a_suppressAudio);
 			}
 
 			void dtor()
 			{
 				using func_t = decltype(&ScopedInventoryChangeMessageContext::dtor);
-				static REL::Relocation<func_t> func{ REL::ID(542100) };
+				static REL::Relocation<func_t> func{ REL::ID(2233293) };
 				return func(this);
 			}
 		};
diff --git a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h
index b8a4f5dc..299f5136 100644
--- a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h
+++ b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h
@@ -19,10 +19,7 @@
 namespace RE
 {
 	enum class CHUNK_ID;
-	enum class SOUND_LEVEL;
 	enum class STAGGER_MAGNITUDE;
-	enum class WEAPON_RUMBLE_PATTERN;
-	enum class WEAPONHITBEHAVIOR;
 
 	class BGSObjectInstanceExtra;
 	class NiAVObject;
@@ -516,6 +513,33 @@ namespace RE
 		kDisableShells = 0x01000000,
 	};
 
+	enum class WEAPON_RUMBLE_PATTERN : std::int32_t
+	{
+		kConstant = 0,
+		kPeriodicSquare = 1,
+		kPeriodicTriangle = 2,
+		kPeriodicSawtooth = 3,
+		kPatternCount = 4
+	};
+
+	enum class WEAPONHITBEHAVIOR : std::int32_t
+	{
+		kNormal = 0,
+		kDismemberOnly = 1,
+		kExplodeOnly = 2,
+		kNoDismemberOrExplode = 3
+	};
+
+	enum class SOUND_LEVEL : std::int32_t
+	{
+		kLoud = 0,
+		kNormal = 1,
+		kSilent = 2,
+		kVeryLoud = 3,
+		kQuiet = 4,
+		kCount = 5
+	};
+
 	class __declspec(novtable) TESObjectWEAP :
 		public TESBoundObject,             // 000
 		public TESFullName,                // 068
diff --git a/CommonLibF4/include/RE/Bethesda/VATS.h b/CommonLibF4/include/RE/Bethesda/VATS.h
index 6265d232..09ab1bc4 100644
--- a/CommonLibF4/include/RE/Bethesda/VATS.h
+++ b/CommonLibF4/include/RE/Bethesda/VATS.h
@@ -21,6 +21,16 @@ namespace RE
 	class TESHitEvent;
 	struct WeaponFiredEvent;
 
+	namespace VATSEvents
+	{
+		struct ModeChange
+		{
+			VATS::VATS_MODE_ENUM oldMode;	// 00
+			VATS::VATS_MODE_ENUM newMode;	// 04
+		};
+		static_assert(sizeof(ModeChange) == 0x8);
+	}
+
 	class __declspec(novtable) VATS :
 		public BSTEventSink<WeaponFiredEvent>,            // 00
 		public BSTEventSink<ProjectileBeginUpdateEvent>,  // 08
diff --git a/CommonLibF4/include/RE/Fallout.h b/CommonLibF4/include/RE/Fallout.h
index 5dbefac7..a83219ce 100644
--- a/CommonLibF4/include/RE/Fallout.h
+++ b/CommonLibF4/include/RE/Fallout.h
@@ -192,11 +192,24 @@
 #include "RE/Bethesda/Movement.h"
 #include "RE/Bethesda/NavMesh.h"
 #include "RE/Bethesda/NavMeshInfoMap.h"
+#include "RE/Bethesda/PipboyArray.h"
 #include "RE/Bethesda/PipboyDataGroup.h"
+#include "RE/Bethesda/PipboyDataManager.h"
 #include "RE/Bethesda/PipboyInventoryData.h"
 #include "RE/Bethesda/PipboyInventoryUtils.h"
+#include "RE/Bethesda/PipboyLogData.h"
 #include "RE/Bethesda/PipboyManager.h"
+#include "RE/Bethesda/PipboyMapData.h"
+#include "RE/Bethesda/PipboyPerksData.h"
+#include "RE/Bethesda/PipboyPlayerInfoData.h"
+#include "RE/Bethesda/PipboyQuestData.h"
+#include "RE/Bethesda/PipboyRadioData.h"
+#include "RE/Bethesda/PipboySpecialData.h"
+#include "RE/Bethesda/PipboyStatsData.h"
+#include "RE/Bethesda/PipboyStatusData.h"
+#include "RE/Bethesda/PipboyThrottleManager.h"
 #include "RE/Bethesda/PipboyValue.h"
+#include "RE/Bethesda/PipboyWorkshopData.h"
 #include "RE/Bethesda/PlayerCharacter.h"
 #include "RE/Bethesda/PlayerControls.h"
 #include "RE/Bethesda/PowerArmor.h"