#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: NavigationSystem

#include "Basic.hpp"

#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "NavigationSystem_structs.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"


namespace SDK
{

// Class NavigationSystem.NavArea
// 0x0018 (0x0048 - 0x0030)
class UNavArea : public UNavAreaBase
{
public:
	float                                         DefaultCost;                                       // 0x0030(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FixedAreaEnteringCost;                             // 0x0034(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FColor                                 DrawColor;                                         // 0x0038(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNavAgentSelector                      SupportedAgents;                                   // 0x003C(0x0004)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bSupportsAgent0 : 1;                               // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent1 : 1;                               // 0x0040(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent2 : 1;                               // 0x0040(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent3 : 1;                               // 0x0040(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent4 : 1;                               // 0x0040(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent5 : 1;                               // 0x0040(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent6 : 1;                               // 0x0040(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent7 : 1;                               // 0x0040(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent8 : 1;                               // 0x0041(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent9 : 1;                               // 0x0041(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent10 : 1;                              // 0x0041(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent11 : 1;                              // 0x0041(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent12 : 1;                              // 0x0041(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent13 : 1;                              // 0x0041(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent14 : 1;                              // 0x0041(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsAgent15 : 1;                              // 0x0041(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_42[0x6];                                       // 0x0042(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavArea">();
	}
	static class UNavArea* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavArea>();
	}
};
static_assert(alignof(UNavArea) == 0x000008, "Wrong alignment on UNavArea");
static_assert(sizeof(UNavArea) == 0x000048, "Wrong size on UNavArea");
static_assert(offsetof(UNavArea, DefaultCost) == 0x000030, "Member 'UNavArea::DefaultCost' has a wrong offset!");
static_assert(offsetof(UNavArea, FixedAreaEnteringCost) == 0x000034, "Member 'UNavArea::FixedAreaEnteringCost' has a wrong offset!");
static_assert(offsetof(UNavArea, DrawColor) == 0x000038, "Member 'UNavArea::DrawColor' has a wrong offset!");
static_assert(offsetof(UNavArea, SupportedAgents) == 0x00003C, "Member 'UNavArea::SupportedAgents' has a wrong offset!");

// Class NavigationSystem.NavArea_Default
// 0x0000 (0x0048 - 0x0048)
class UNavArea_Default final : public UNavArea
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavArea_Default">();
	}
	static class UNavArea_Default* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavArea_Default>();
	}
};
static_assert(alignof(UNavArea_Default) == 0x000008, "Wrong alignment on UNavArea_Default");
static_assert(sizeof(UNavArea_Default) == 0x000048, "Wrong size on UNavArea_Default");

// Class NavigationSystem.NavLinkRenderingComponent
// 0x0000 (0x0450 - 0x0450)
class UNavLinkRenderingComponent : public UPrimitiveComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkRenderingComponent">();
	}
	static class UNavLinkRenderingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavLinkRenderingComponent>();
	}
};
static_assert(alignof(UNavLinkRenderingComponent) == 0x000010, "Wrong alignment on UNavLinkRenderingComponent");
static_assert(sizeof(UNavLinkRenderingComponent) == 0x000450, "Wrong size on UNavLinkRenderingComponent");

// Class NavigationSystem.NavigationData
// 0x0208 (0x0428 - 0x0220)
class ANavigationData : public AActor
{
public:
	uint8                                         Pad_220[0x8];                                      // 0x0220(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UPrimitiveComponent*                    RenderingComp;                                     // 0x0228(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNavDataConfig                         NavDataConfig;                                     // 0x0230(0x0078)(Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bEnableDrawing : 1;                                // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bForceRebuildOnLoad : 1;                           // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAutoDestroyWhenNoNavigation : 1;                  // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCanBeMainNavData : 1;                             // 0x02A8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCanSpawnOnRebuild : 1;                            // 0x02A8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, EditConst, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bRebuildAtRuntime : 1;                             // 0x02A8(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Config, Deprecated, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_2A9[0x3];                                      // 0x02A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ERuntimeGenerationType                        RuntimeGeneration;                                 // 0x02AC(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2AD[0x3];                                      // 0x02AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ObservedPathsTickInterval;                         // 0x02B0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint32                                        DataVersion;                                       // 0x02B4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2B8[0x108];                                    // 0x02B8(0x0108)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSupportedAreaData>             SupportedAreas;                                    // 0x03C0(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_3D0[0x58];                                     // 0x03D0(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationData">();
	}
	static class ANavigationData* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationData>();
	}
};
static_assert(alignof(ANavigationData) == 0x000008, "Wrong alignment on ANavigationData");
static_assert(sizeof(ANavigationData) == 0x000428, "Wrong size on ANavigationData");
static_assert(offsetof(ANavigationData, RenderingComp) == 0x000228, "Member 'ANavigationData::RenderingComp' has a wrong offset!");
static_assert(offsetof(ANavigationData, NavDataConfig) == 0x000230, "Member 'ANavigationData::NavDataConfig' has a wrong offset!");
static_assert(offsetof(ANavigationData, RuntimeGeneration) == 0x0002AC, "Member 'ANavigationData::RuntimeGeneration' has a wrong offset!");
static_assert(offsetof(ANavigationData, ObservedPathsTickInterval) == 0x0002B0, "Member 'ANavigationData::ObservedPathsTickInterval' has a wrong offset!");
static_assert(offsetof(ANavigationData, DataVersion) == 0x0002B4, "Member 'ANavigationData::DataVersion' has a wrong offset!");
static_assert(offsetof(ANavigationData, SupportedAreas) == 0x0003C0, "Member 'ANavigationData::SupportedAreas' has a wrong offset!");

// Class NavigationSystem.NavAreaMeta
// 0x0000 (0x0048 - 0x0048)
class UNavAreaMeta : public UNavArea
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavAreaMeta">();
	}
	static class UNavAreaMeta* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavAreaMeta>();
	}
};
static_assert(alignof(UNavAreaMeta) == 0x000008, "Wrong alignment on UNavAreaMeta");
static_assert(sizeof(UNavAreaMeta) == 0x000048, "Wrong size on UNavAreaMeta");

// Class NavigationSystem.AbstractNavData
// 0x0000 (0x0428 - 0x0428)
class AAbstractNavData final : public ANavigationData
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbstractNavData">();
	}
	static class AAbstractNavData* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAbstractNavData>();
	}
};
static_assert(alignof(AAbstractNavData) == 0x000008, "Wrong alignment on AAbstractNavData");
static_assert(sizeof(AAbstractNavData) == 0x000428, "Wrong size on AAbstractNavData");

// Class NavigationSystem.CrowdManagerBase
// 0x0000 (0x0028 - 0x0028)
class UCrowdManagerBase : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CrowdManagerBase">();
	}
	static class UCrowdManagerBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCrowdManagerBase>();
	}
};
static_assert(alignof(UCrowdManagerBase) == 0x000008, "Wrong alignment on UCrowdManagerBase");
static_assert(sizeof(UCrowdManagerBase) == 0x000028, "Wrong size on UCrowdManagerBase");

// Class NavigationSystem.NavigationGraphNode
// 0x0000 (0x0220 - 0x0220)
class ANavigationGraphNode final : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationGraphNode">();
	}
	static class ANavigationGraphNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationGraphNode>();
	}
};
static_assert(alignof(ANavigationGraphNode) == 0x000008, "Wrong alignment on ANavigationGraphNode");
static_assert(sizeof(ANavigationGraphNode) == 0x000220, "Wrong size on ANavigationGraphNode");

// Class NavigationSystem.NavArea_LowHeight
// 0x0000 (0x0048 - 0x0048)
class UNavArea_LowHeight final : public UNavArea
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavArea_LowHeight">();
	}
	static class UNavArea_LowHeight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavArea_LowHeight>();
	}
};
static_assert(alignof(UNavArea_LowHeight) == 0x000008, "Wrong alignment on UNavArea_LowHeight");
static_assert(sizeof(UNavArea_LowHeight) == 0x000048, "Wrong size on UNavArea_LowHeight");

// Class NavigationSystem.NavArea_Null
// 0x0000 (0x0048 - 0x0048)
class UNavArea_Null final : public UNavArea
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavArea_Null">();
	}
	static class UNavArea_Null* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavArea_Null>();
	}
};
static_assert(alignof(UNavArea_Null) == 0x000008, "Wrong alignment on UNavArea_Null");
static_assert(sizeof(UNavArea_Null) == 0x000048, "Wrong size on UNavArea_Null");

// Class NavigationSystem.NavArea_Obstacle
// 0x0000 (0x0048 - 0x0048)
class UNavArea_Obstacle final : public UNavArea
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavArea_Obstacle">();
	}
	static class UNavArea_Obstacle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavArea_Obstacle>();
	}
};
static_assert(alignof(UNavArea_Obstacle) == 0x000008, "Wrong alignment on UNavArea_Obstacle");
static_assert(sizeof(UNavArea_Obstacle) == 0x000048, "Wrong size on UNavArea_Obstacle");

// Class NavigationSystem.NavAreaMeta_SwitchByAgent
// 0x0080 (0x00C8 - 0x0048)
class UNavAreaMeta_SwitchByAgent final : public UNavAreaMeta
{
public:
	TSubclassOf<class UNavArea>                   Agent0Area;                                        // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent1Area;                                        // 0x0050(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent2Area;                                        // 0x0058(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent3Area;                                        // 0x0060(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent4Area;                                        // 0x0068(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent5Area;                                        // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent6Area;                                        // 0x0078(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent7Area;                                        // 0x0080(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent8Area;                                        // 0x0088(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent9Area;                                        // 0x0090(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent10Area;                                       // 0x0098(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent11Area;                                       // 0x00A0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent12Area;                                       // 0x00A8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent13Area;                                       // 0x00B0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent14Area;                                       // 0x00B8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   Agent15Area;                                       // 0x00C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavAreaMeta_SwitchByAgent">();
	}
	static class UNavAreaMeta_SwitchByAgent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavAreaMeta_SwitchByAgent>();
	}
};
static_assert(alignof(UNavAreaMeta_SwitchByAgent) == 0x000008, "Wrong alignment on UNavAreaMeta_SwitchByAgent");
static_assert(sizeof(UNavAreaMeta_SwitchByAgent) == 0x0000C8, "Wrong size on UNavAreaMeta_SwitchByAgent");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent0Area) == 0x000048, "Member 'UNavAreaMeta_SwitchByAgent::Agent0Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent1Area) == 0x000050, "Member 'UNavAreaMeta_SwitchByAgent::Agent1Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent2Area) == 0x000058, "Member 'UNavAreaMeta_SwitchByAgent::Agent2Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent3Area) == 0x000060, "Member 'UNavAreaMeta_SwitchByAgent::Agent3Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent4Area) == 0x000068, "Member 'UNavAreaMeta_SwitchByAgent::Agent4Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent5Area) == 0x000070, "Member 'UNavAreaMeta_SwitchByAgent::Agent5Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent6Area) == 0x000078, "Member 'UNavAreaMeta_SwitchByAgent::Agent6Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent7Area) == 0x000080, "Member 'UNavAreaMeta_SwitchByAgent::Agent7Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent8Area) == 0x000088, "Member 'UNavAreaMeta_SwitchByAgent::Agent8Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent9Area) == 0x000090, "Member 'UNavAreaMeta_SwitchByAgent::Agent9Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent10Area) == 0x000098, "Member 'UNavAreaMeta_SwitchByAgent::Agent10Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent11Area) == 0x0000A0, "Member 'UNavAreaMeta_SwitchByAgent::Agent11Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent12Area) == 0x0000A8, "Member 'UNavAreaMeta_SwitchByAgent::Agent12Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent13Area) == 0x0000B0, "Member 'UNavAreaMeta_SwitchByAgent::Agent13Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent14Area) == 0x0000B8, "Member 'UNavAreaMeta_SwitchByAgent::Agent14Area' has a wrong offset!");
static_assert(offsetof(UNavAreaMeta_SwitchByAgent, Agent15Area) == 0x0000C0, "Member 'UNavAreaMeta_SwitchByAgent::Agent15Area' has a wrong offset!");

// Class NavigationSystem.NavCollision
// 0x0068 (0x00D8 - 0x0070)
class UNavCollision final : public UNavCollisionBase
{
public:
	uint8                                         Pad_70[0x10];                                      // 0x0070(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FNavCollisionCylinder>          CylinderCollision;                                 // 0x0080(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FNavCollisionBox>               BoxCollision;                                      // 0x0090(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavArea>                   AreaClass;                                         // 0x00A0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bGatherConvexGeometry : 1;                         // 0x00A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCreateOnClient : 1;                               // 0x00A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A9[0x2F];                                      // 0x00A9(0x002F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavCollision">();
	}
	static class UNavCollision* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavCollision>();
	}
};
static_assert(alignof(UNavCollision) == 0x000008, "Wrong alignment on UNavCollision");
static_assert(sizeof(UNavCollision) == 0x0000D8, "Wrong size on UNavCollision");
static_assert(offsetof(UNavCollision, CylinderCollision) == 0x000080, "Member 'UNavCollision::CylinderCollision' has a wrong offset!");
static_assert(offsetof(UNavCollision, BoxCollision) == 0x000090, "Member 'UNavCollision::BoxCollision' has a wrong offset!");
static_assert(offsetof(UNavCollision, AreaClass) == 0x0000A0, "Member 'UNavCollision::AreaClass' has a wrong offset!");

// Class NavigationSystem.NavigationGraph
// 0x0000 (0x0428 - 0x0428)
class ANavigationGraph final : public ANavigationData
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationGraph">();
	}
	static class ANavigationGraph* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationGraph>();
	}
};
static_assert(alignof(ANavigationGraph) == 0x000008, "Wrong alignment on ANavigationGraph");
static_assert(sizeof(ANavigationGraph) == 0x000428, "Wrong size on ANavigationGraph");

// Class NavigationSystem.NavigationGraphNodeComponent
// 0x0020 (0x0220 - 0x0200)
class UNavigationGraphNodeComponent final : public USceneComponent
{
public:
	struct FNavGraphNode                          Node;                                              // 0x01F8(0x0018)(NativeAccessSpecifierPublic)
	class UNavigationGraphNodeComponent*          NextNodeComponent;                                 // 0x0210(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavigationGraphNodeComponent*          PrevNodeComponent;                                 // 0x0218(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationGraphNodeComponent">();
	}
	static class UNavigationGraphNodeComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationGraphNodeComponent>();
	}
};
static_assert(alignof(UNavigationGraphNodeComponent) == 0x000010, "Wrong alignment on UNavigationGraphNodeComponent");
static_assert(sizeof(UNavigationGraphNodeComponent) == 0x000220, "Wrong size on UNavigationGraphNodeComponent");
static_assert(offsetof(UNavigationGraphNodeComponent, Node) == 0x0001F8, "Member 'UNavigationGraphNodeComponent::Node' has a wrong offset!");
static_assert(offsetof(UNavigationGraphNodeComponent, NextNodeComponent) == 0x000210, "Member 'UNavigationGraphNodeComponent::NextNodeComponent' has a wrong offset!");
static_assert(offsetof(UNavigationGraphNodeComponent, PrevNodeComponent) == 0x000218, "Member 'UNavigationGraphNodeComponent::PrevNodeComponent' has a wrong offset!");

// Class NavigationSystem.NavigationInvokerComponent
// 0x0008 (0x00B8 - 0x00B0)
class UNavigationInvokerComponent final : public UActorComponent
{
public:
	float                                         TileGenerationRadius;                              // 0x00B0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         TileRemovalRadius;                                 // 0x00B4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationInvokerComponent">();
	}
	static class UNavigationInvokerComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationInvokerComponent>();
	}
};
static_assert(alignof(UNavigationInvokerComponent) == 0x000008, "Wrong alignment on UNavigationInvokerComponent");
static_assert(sizeof(UNavigationInvokerComponent) == 0x0000B8, "Wrong size on UNavigationInvokerComponent");
static_assert(offsetof(UNavigationInvokerComponent, TileGenerationRadius) == 0x0000B0, "Member 'UNavigationInvokerComponent::TileGenerationRadius' has a wrong offset!");
static_assert(offsetof(UNavigationInvokerComponent, TileRemovalRadius) == 0x0000B4, "Member 'UNavigationInvokerComponent::TileRemovalRadius' has a wrong offset!");

// Class NavigationSystem.NavigationPath
// 0x0060 (0x0088 - 0x0028)
class UNavigationPath final : public UObject
{
public:
	TMulticastInlineDelegate<void(class UNavigationPath* AffectedPath, ENavPathEvent PathEvent)> PathUpdatedNotifier; // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TArray<struct FVector>                        PathPoints;                                        // 0x0038(0x0010)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	ENavigationOptionFlag                         RecalculateOnInvalidation;                         // 0x0048(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3F];                                      // 0x0049(0x003F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void EnableDebugDrawing(bool bShouldDrawDebugData, const struct FLinearColor& PathColor);
	void EnableRecalculationOnInvalidation(ENavigationOptionFlag DoRecalculation);

	class FString GetDebugString() const;
	float GetPathCost() const;
	float GetPathLength() const;
	bool IsPartial() const;
	bool IsStringPulled() const;
	bool IsValid() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationPath">();
	}
	static class UNavigationPath* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationPath>();
	}
};
static_assert(alignof(UNavigationPath) == 0x000008, "Wrong alignment on UNavigationPath");
static_assert(sizeof(UNavigationPath) == 0x000088, "Wrong size on UNavigationPath");
static_assert(offsetof(UNavigationPath, PathUpdatedNotifier) == 0x000028, "Member 'UNavigationPath::PathUpdatedNotifier' has a wrong offset!");
static_assert(offsetof(UNavigationPath, PathPoints) == 0x000038, "Member 'UNavigationPath::PathPoints' has a wrong offset!");
static_assert(offsetof(UNavigationPath, RecalculateOnInvalidation) == 0x000048, "Member 'UNavigationPath::RecalculateOnInvalidation' has a wrong offset!");

// Class NavigationSystem.NavigationPathGenerator
// 0x0000 (0x0000 - 0x0000)
class INavigationPathGenerator final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationPathGenerator">();
	}
	static class INavigationPathGenerator* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavigationPathGenerator>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavigationPathGenerator) == 0x000001, "Wrong alignment on INavigationPathGenerator");
static_assert(sizeof(INavigationPathGenerator) == 0x000001, "Wrong size on INavigationPathGenerator");

// Class NavigationSystem.NavigationQueryFilter
// 0x0020 (0x0048 - 0x0028)
class UNavigationQueryFilter : public UObject
{
public:
	TArray<struct FNavigationFilterArea>          Areas;                                             // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FNavigationFilterFlags                 IncludeFlags;                                      // 0x0038(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavigationFilterFlags                 ExcludeFlags;                                      // 0x003C(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x8];                                       // 0x0040(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationQueryFilter">();
	}
	static class UNavigationQueryFilter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationQueryFilter>();
	}
};
static_assert(alignof(UNavigationQueryFilter) == 0x000008, "Wrong alignment on UNavigationQueryFilter");
static_assert(sizeof(UNavigationQueryFilter) == 0x000048, "Wrong size on UNavigationQueryFilter");
static_assert(offsetof(UNavigationQueryFilter, Areas) == 0x000028, "Member 'UNavigationQueryFilter::Areas' has a wrong offset!");
static_assert(offsetof(UNavigationQueryFilter, IncludeFlags) == 0x000038, "Member 'UNavigationQueryFilter::IncludeFlags' has a wrong offset!");
static_assert(offsetof(UNavigationQueryFilter, ExcludeFlags) == 0x00003C, "Member 'UNavigationQueryFilter::ExcludeFlags' has a wrong offset!");

// Class NavigationSystem.NavigationSystemV1
// 0x15B8 (0x15E0 - 0x0028)
class UNavigationSystemV1 final : public UNavigationSystemBase
{
public:
	class ANavigationData*                        MainNavData;                                       // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ANavigationData*                        AbstractNavData;                                   // 0x0030(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   DefaultAgentName;                                  // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSoftClassPtr<class UClass>                   CrowdManagerClass;                                 // 0x0040(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, Config, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bAutoCreateNavigationData : 1;                     // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bSpawnNavDataInNavBoundsLevel : 1;                 // 0x0068(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAllowClientSideNavigation : 1;                    // 0x0068(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bShouldDiscardSubLevelNavData : 1;                 // 0x0068(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bTickWhilePaused : 1;                              // 0x0068(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bSupportRebuilding : 1;                            // 0x0068(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bInitialBuildingLocked : 1;                        // 0x0068(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_68_7 : 1;                                   // 0x0068(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         bSkipAgentHeightCheckWhenPickingNavData : 1;       // 0x0069(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateNavigationOnlyAroundNavigationInvokers : 1; // 0x0069(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_6A[0x2];                                       // 0x006A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ActiveTilesUpdateInterval;                         // 0x006C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ENavDataGatheringModeConfig                   DataGatheringMode;                                 // 0x0070(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_71[0x3];                                       // 0x0071(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DirtyAreaWarningSizeThreshold;                     // 0x0074(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FNavDataConfig>                 SupportedAgents;                                   // 0x0078(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	struct FNavAgentSelector                      SupportedAgentsMask;                               // 0x0088(0x0004)(Edit, Config, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_8C[0x4];                                       // 0x008C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class ANavigationData*>                NavDataSet;                                        // 0x0090(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TArray<class ANavigationData*>                NavDataRegistrationQueue;                          // 0x00A0(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_B0[0x10];                                      // 0x00B0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class ANavigationData* NavData)> OnNavDataRegisteredEvent;         // 0x00C0(0x0010)(ZeroConstructor, Transient, InstancedReference, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class ANavigationData* NavData)> OnNavigationGenerationFinishedDelegate; // 0x00D0(0x0010)(ZeroConstructor, Transient, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_E0[0xDC];                                      // 0x00E0(0x00DC)(Fixing Size After Last Property [ Dumper-7 ])
	EFNavigationSystemRunMode                     OperationMode;                                     // 0x01BC(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1BD[0x13FF];                                   // 0x01BD(0x13FF)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DirtyAreasUpdateFreq;                              // 0x15BC(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15C0[0x20];                                    // 0x15C0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UNavigationPath* FindPathToActorSynchronously(class UObject* WorldContextObject, const struct FVector& PathStart, class AActor* GoalActor, float TetherDistance, class AActor* PathfindingContext, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static class UNavigationPath* FindPathToLocationSynchronously(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, class AActor* PathfindingContext, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static class UNavigationSystemV1* GetNavigationSystem(class UObject* WorldContextObject);
	static ENavigationQueryResult GetPathCost(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, float* PathCost, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static ENavigationQueryResult GetPathLength(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, float* PathLength, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static struct FVector GetRandomPointInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static struct FVector GetRandomReachablePointInRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static bool IsNavigationBeingBuilt(class UObject* WorldContextObject);
	static bool IsNavigationBeingBuiltOrLocked(class UObject* WorldContextObject);
	static bool K2_GetRandomLocationInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, struct FVector* RandomLocation, float Radius, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static bool K2_GetRandomPointInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, struct FVector* RandomLocation, float Radius, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static bool K2_GetRandomReachablePointInRadius(class UObject* WorldContextObject, const struct FVector& Origin, struct FVector* RandomLocation, float Radius, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass);
	static bool K2_ProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, struct FVector* ProjectedLocation, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass, const struct FVector& QueryExtent);
	static bool NavigationRaycast(class UObject* WorldContextObject, const struct FVector& RayStart, const struct FVector& RayEnd, struct FVector* HitLocation, TSubclassOf<class UNavigationQueryFilter> FilterClass, class AController* Querier);
	static struct FVector ProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass, const struct FVector& QueryExtent);
	static void SimpleMoveToActor(class AController* Controller, const class AActor* Goal);
	static void SimpleMoveToLocation(class AController* Controller, const struct FVector& Goal);

	bool K2_ReplaceAreaInOctreeData(const class UObject* Object, TSubclassOf<class UNavArea> OldArea, TSubclassOf<class UNavArea> NewArea);
	void OnNavigationBoundsUpdated(class ANavMeshBoundsVolume* NavVolume);
	void RegisterNavigationInvoker(class AActor* Invoker, float TileGenerationRadius, float TileRemovalRadius);
	void ResetMaxSimultaneousTileGenerationJobsCount();
	void SetGeometryGatheringMode(ENavDataGatheringModeConfig NewMode);
	void SetMaxSimultaneousTileGenerationJobsCount(int32 MaxNumberOfJobs);
	void UnregisterNavigationInvoker(class AActor* Invoker);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationSystemV1">();
	}
	static class UNavigationSystemV1* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationSystemV1>();
	}
};
static_assert(alignof(UNavigationSystemV1) == 0x000008, "Wrong alignment on UNavigationSystemV1");
static_assert(sizeof(UNavigationSystemV1) == 0x0015E0, "Wrong size on UNavigationSystemV1");
static_assert(offsetof(UNavigationSystemV1, MainNavData) == 0x000028, "Member 'UNavigationSystemV1::MainNavData' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, AbstractNavData) == 0x000030, "Member 'UNavigationSystemV1::AbstractNavData' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, DefaultAgentName) == 0x000038, "Member 'UNavigationSystemV1::DefaultAgentName' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, CrowdManagerClass) == 0x000040, "Member 'UNavigationSystemV1::CrowdManagerClass' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, ActiveTilesUpdateInterval) == 0x00006C, "Member 'UNavigationSystemV1::ActiveTilesUpdateInterval' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, DataGatheringMode) == 0x000070, "Member 'UNavigationSystemV1::DataGatheringMode' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, DirtyAreaWarningSizeThreshold) == 0x000074, "Member 'UNavigationSystemV1::DirtyAreaWarningSizeThreshold' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, SupportedAgents) == 0x000078, "Member 'UNavigationSystemV1::SupportedAgents' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, SupportedAgentsMask) == 0x000088, "Member 'UNavigationSystemV1::SupportedAgentsMask' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, NavDataSet) == 0x000090, "Member 'UNavigationSystemV1::NavDataSet' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, NavDataRegistrationQueue) == 0x0000A0, "Member 'UNavigationSystemV1::NavDataRegistrationQueue' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, OnNavDataRegisteredEvent) == 0x0000C0, "Member 'UNavigationSystemV1::OnNavDataRegisteredEvent' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, OnNavigationGenerationFinishedDelegate) == 0x0000D0, "Member 'UNavigationSystemV1::OnNavigationGenerationFinishedDelegate' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, OperationMode) == 0x0001BC, "Member 'UNavigationSystemV1::OperationMode' has a wrong offset!");
static_assert(offsetof(UNavigationSystemV1, DirtyAreasUpdateFreq) == 0x0015BC, "Member 'UNavigationSystemV1::DirtyAreasUpdateFreq' has a wrong offset!");

// Class NavigationSystem.NavigationSystemModuleConfig
// 0x0008 (0x0048 - 0x0040)
class UNavigationSystemModuleConfig final : public UNavigationSystemConfig
{
public:
	uint8                                         bStrictlyStatic : 1;                               // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCreateOnClient : 1;                               // 0x0040(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAutoSpawnMissingNavData : 1;                      // 0x0040(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bSpawnNavDataInNavBoundsLevel : 1;                 // 0x0040(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationSystemModuleConfig">();
	}
	static class UNavigationSystemModuleConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationSystemModuleConfig>();
	}
};
static_assert(alignof(UNavigationSystemModuleConfig) == 0x000008, "Wrong alignment on UNavigationSystemModuleConfig");
static_assert(sizeof(UNavigationSystemModuleConfig) == 0x000048, "Wrong size on UNavigationSystemModuleConfig");

// Class NavigationSystem.NavigationTestingActor
// 0x00F0 (0x0310 - 0x0220)
class ANavigationTestingActor final : public AActor
{
public:
	uint8                                         Pad_220[0x10];                                     // 0x0220(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UCapsuleComponent*                      CapsuleComponent;                                  // 0x0230(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UNavigationInvokerComponent*            InvokerComponent;                                  // 0x0238(0x0008)(Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bActAsNavigationInvoker : 1;                       // 0x0240(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_241[0x7];                                      // 0x0241(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNavAgentProperties                    NavAgentProps;                                     // 0x0248(0x0030)(Edit, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                QueryingExtent;                                    // 0x0278(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_284[0x4];                                      // 0x0284(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class ANavigationData*                        MyNavData;                                         // 0x0288(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ProjectedLocation;                                 // 0x0290(0x000C)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bProjectedLocationValid : 1;                       // 0x029C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSearchStart : 1;                                  // 0x029C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_29D[0x3];                                      // 0x029D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CostLimitFactor;                                   // 0x02A0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinimumCostLimit;                                  // 0x02A4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bBacktracking : 1;                                 // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseHierarchicalPathfinding : 1;                   // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGatherDetailedInfo : 1;                           // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawDistanceToWall : 1;                           // 0x02A8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowNodePool : 1;                                 // 0x02A8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowBestPath : 1;                                 // 0x02A8(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowDiffWithPreviousStep : 1;                     // 0x02A8(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldBeVisibleInGame : 1;                        // 0x02A8(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x3];                                      // 0x02A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ENavCostDisplay                               CostDisplayMode;                                   // 0x02AC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2AD[0x3];                                      // 0x02AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              TextCanvasOffset;                                  // 0x02B0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPathExist : 1;                                    // 0x02B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPathIsPartial : 1;                                // 0x02B8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPathSearchOutOfNodes : 1;                         // 0x02B8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2B9[0x3];                                      // 0x02B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PathfindingTime;                                   // 0x02BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PathCost;                                          // 0x02C0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PathfindingSteps;                                  // 0x02C4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ANavigationTestingActor*                OtherActor;                                        // 0x02C8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavigationQueryFilter>     FilterClass;                                       // 0x02D0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ShowStepIndex;                                     // 0x02D8(0x0004)(Edit, ZeroConstructor, DisableEditOnTemplate, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OffsetFromCornersDistance;                         // 0x02DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E0[0x30];                                     // 0x02E0(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationTestingActor">();
	}
	static class ANavigationTestingActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationTestingActor>();
	}
};
static_assert(alignof(ANavigationTestingActor) == 0x000008, "Wrong alignment on ANavigationTestingActor");
static_assert(sizeof(ANavigationTestingActor) == 0x000310, "Wrong size on ANavigationTestingActor");
static_assert(offsetof(ANavigationTestingActor, CapsuleComponent) == 0x000230, "Member 'ANavigationTestingActor::CapsuleComponent' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, InvokerComponent) == 0x000238, "Member 'ANavigationTestingActor::InvokerComponent' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, NavAgentProps) == 0x000248, "Member 'ANavigationTestingActor::NavAgentProps' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, QueryingExtent) == 0x000278, "Member 'ANavigationTestingActor::QueryingExtent' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, MyNavData) == 0x000288, "Member 'ANavigationTestingActor::MyNavData' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, ProjectedLocation) == 0x000290, "Member 'ANavigationTestingActor::ProjectedLocation' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, CostLimitFactor) == 0x0002A0, "Member 'ANavigationTestingActor::CostLimitFactor' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, MinimumCostLimit) == 0x0002A4, "Member 'ANavigationTestingActor::MinimumCostLimit' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, CostDisplayMode) == 0x0002AC, "Member 'ANavigationTestingActor::CostDisplayMode' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, TextCanvasOffset) == 0x0002B0, "Member 'ANavigationTestingActor::TextCanvasOffset' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, PathfindingTime) == 0x0002BC, "Member 'ANavigationTestingActor::PathfindingTime' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, PathCost) == 0x0002C0, "Member 'ANavigationTestingActor::PathCost' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, PathfindingSteps) == 0x0002C4, "Member 'ANavigationTestingActor::PathfindingSteps' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, OtherActor) == 0x0002C8, "Member 'ANavigationTestingActor::OtherActor' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, FilterClass) == 0x0002D0, "Member 'ANavigationTestingActor::FilterClass' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, ShowStepIndex) == 0x0002D8, "Member 'ANavigationTestingActor::ShowStepIndex' has a wrong offset!");
static_assert(offsetof(ANavigationTestingActor, OffsetFromCornersDistance) == 0x0002DC, "Member 'ANavigationTestingActor::OffsetFromCornersDistance' has a wrong offset!");

// Class NavigationSystem.NavLinkComponent
// 0x0020 (0x0470 - 0x0450)
class UNavLinkComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_450[0x8];                                      // 0x0450(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FNavigationLink>                Links;                                             // 0x0458(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_468[0x8];                                      // 0x0468(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkComponent">();
	}
	static class UNavLinkComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavLinkComponent>();
	}
};
static_assert(alignof(UNavLinkComponent) == 0x000010, "Wrong alignment on UNavLinkComponent");
static_assert(sizeof(UNavLinkComponent) == 0x000470, "Wrong size on UNavLinkComponent");
static_assert(offsetof(UNavLinkComponent, Links) == 0x000458, "Member 'UNavLinkComponent::Links' has a wrong offset!");

// Class NavigationSystem.NavRelevantComponent
// 0x0030 (0x00E0 - 0x00B0)
class UNavRelevantComponent : public UActorComponent
{
public:
	uint8                                         Pad_B0[0x24];                                      // 0x00B0(0x0024)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bAttachToOwnersRoot : 1;                           // 0x00D4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_D5[0x3];                                       // 0x00D5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UObject*                                CachedNavParent;                                   // 0x00D8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void SetNavigationRelevancy(bool bRelevant);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavRelevantComponent">();
	}
	static class UNavRelevantComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavRelevantComponent>();
	}
};
static_assert(alignof(UNavRelevantComponent) == 0x000008, "Wrong alignment on UNavRelevantComponent");
static_assert(sizeof(UNavRelevantComponent) == 0x0000E0, "Wrong size on UNavRelevantComponent");
static_assert(offsetof(UNavRelevantComponent, CachedNavParent) == 0x0000D8, "Member 'UNavRelevantComponent::CachedNavParent' has a wrong offset!");

// Class NavigationSystem.NavLinkCustomComponent
// 0x00B0 (0x0190 - 0x00E0)
class UNavLinkCustomComponent final : public UNavRelevantComponent
{
public:
	uint8                                         Pad_E0[0x8];                                       // 0x00E0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        NavLinkUserId;                                     // 0x00E8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_EC[0x4];                                       // 0x00EC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavArea>                   EnabledAreaClass;                                  // 0x00F0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UNavArea>                   DisabledAreaClass;                                 // 0x00F8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FNavAgentSelector                      SupportedAgents;                                   // 0x0100(0x0004)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FVector                                LinkRelativeStart;                                 // 0x0104(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                LinkRelativeEnd;                                   // 0x0110(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ENavLinkDirection                             LinkDirection;                                     // 0x011C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_11D[0x3];                                      // 0x011D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bLinkEnabled : 1;                                  // 0x0120(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bNotifyWhenEnabled : 1;                            // 0x0120(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bNotifyWhenDisabled : 1;                           // 0x0120(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCreateBoxObstacle : 1;                            // 0x0120(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ObstacleOffset;                                    // 0x0124(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                ObstacleExtent;                                    // 0x0130(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_13C[0x4];                                      // 0x013C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavArea>                   ObstacleAreaClass;                                 // 0x0140(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         BroadcastRadius;                                   // 0x0148(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         BroadcastInterval;                                 // 0x014C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ECollisionChannel                             BroadcastChannel;                                  // 0x0150(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_151[0x3F];                                     // 0x0151(0x003F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkCustomComponent">();
	}
	static class UNavLinkCustomComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavLinkCustomComponent>();
	}
};
static_assert(alignof(UNavLinkCustomComponent) == 0x000008, "Wrong alignment on UNavLinkCustomComponent");
static_assert(sizeof(UNavLinkCustomComponent) == 0x000190, "Wrong size on UNavLinkCustomComponent");
static_assert(offsetof(UNavLinkCustomComponent, NavLinkUserId) == 0x0000E8, "Member 'UNavLinkCustomComponent::NavLinkUserId' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, EnabledAreaClass) == 0x0000F0, "Member 'UNavLinkCustomComponent::EnabledAreaClass' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, DisabledAreaClass) == 0x0000F8, "Member 'UNavLinkCustomComponent::DisabledAreaClass' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, SupportedAgents) == 0x000100, "Member 'UNavLinkCustomComponent::SupportedAgents' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, LinkRelativeStart) == 0x000104, "Member 'UNavLinkCustomComponent::LinkRelativeStart' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, LinkRelativeEnd) == 0x000110, "Member 'UNavLinkCustomComponent::LinkRelativeEnd' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, LinkDirection) == 0x00011C, "Member 'UNavLinkCustomComponent::LinkDirection' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, ObstacleOffset) == 0x000124, "Member 'UNavLinkCustomComponent::ObstacleOffset' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, ObstacleExtent) == 0x000130, "Member 'UNavLinkCustomComponent::ObstacleExtent' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, ObstacleAreaClass) == 0x000140, "Member 'UNavLinkCustomComponent::ObstacleAreaClass' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, BroadcastRadius) == 0x000148, "Member 'UNavLinkCustomComponent::BroadcastRadius' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, BroadcastInterval) == 0x00014C, "Member 'UNavLinkCustomComponent::BroadcastInterval' has a wrong offset!");
static_assert(offsetof(UNavLinkCustomComponent, BroadcastChannel) == 0x000150, "Member 'UNavLinkCustomComponent::BroadcastChannel' has a wrong offset!");

// Class NavigationSystem.NavLinkCustomInterface
// 0x0000 (0x0000 - 0x0000)
class INavLinkCustomInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkCustomInterface">();
	}
	static class INavLinkCustomInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavLinkCustomInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavLinkCustomInterface) == 0x000001, "Wrong alignment on INavLinkCustomInterface");
static_assert(sizeof(INavLinkCustomInterface) == 0x000001, "Wrong size on INavLinkCustomInterface");

// Class NavigationSystem.NavLinkHostInterface
// 0x0000 (0x0000 - 0x0000)
class INavLinkHostInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkHostInterface">();
	}
	static class INavLinkHostInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavLinkHostInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavLinkHostInterface) == 0x000001, "Wrong alignment on INavLinkHostInterface");
static_assert(sizeof(INavLinkHostInterface) == 0x000001, "Wrong size on INavLinkHostInterface");

// Class NavigationSystem.NavLinkTrivial
// 0x0000 (0x0050 - 0x0050)
class UNavLinkTrivial final : public UNavLinkDefinition
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkTrivial">();
	}
	static class UNavLinkTrivial* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavLinkTrivial>();
	}
};
static_assert(alignof(UNavLinkTrivial) == 0x000008, "Wrong alignment on UNavLinkTrivial");
static_assert(sizeof(UNavLinkTrivial) == 0x000050, "Wrong size on UNavLinkTrivial");

// Class NavigationSystem.NavMeshBoundsVolume
// 0x0008 (0x0260 - 0x0258)
class ANavMeshBoundsVolume final : public AVolume
{
public:
	struct FNavAgentSelector                      SupportedAgents;                                   // 0x0258(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_25C[0x4];                                      // 0x025C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavMeshBoundsVolume">();
	}
	static class ANavMeshBoundsVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavMeshBoundsVolume>();
	}
};
static_assert(alignof(ANavMeshBoundsVolume) == 0x000008, "Wrong alignment on ANavMeshBoundsVolume");
static_assert(sizeof(ANavMeshBoundsVolume) == 0x000260, "Wrong size on ANavMeshBoundsVolume");
static_assert(offsetof(ANavMeshBoundsVolume, SupportedAgents) == 0x000258, "Member 'ANavMeshBoundsVolume::SupportedAgents' has a wrong offset!");

// Class NavigationSystem.NavMeshRenderingComponent
// 0x0010 (0x0460 - 0x0450)
class UNavMeshRenderingComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_450[0x10];                                     // 0x0450(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavMeshRenderingComponent">();
	}
	static class UNavMeshRenderingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavMeshRenderingComponent>();
	}
};
static_assert(alignof(UNavMeshRenderingComponent) == 0x000010, "Wrong alignment on UNavMeshRenderingComponent");
static_assert(sizeof(UNavMeshRenderingComponent) == 0x000460, "Wrong size on UNavMeshRenderingComponent");

// Class NavigationSystem.NavModifierComponent
// 0x0060 (0x0140 - 0x00E0)
class alignas(0x10) UNavModifierComponent final : public UNavRelevantComponent
{
public:
	TSubclassOf<class UNavArea>                   AreaClass;                                         // 0x00E0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                FailsafeExtent;                                    // 0x00E8(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIncludeAgentHeight : 1;                           // 0x00F4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F5[0x4B];                                      // 0x00F5(0x004B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAreaClass(TSubclassOf<class UNavArea> NewAreaClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavModifierComponent">();
	}
	static class UNavModifierComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavModifierComponent>();
	}
};
static_assert(alignof(UNavModifierComponent) == 0x000010, "Wrong alignment on UNavModifierComponent");
static_assert(sizeof(UNavModifierComponent) == 0x000140, "Wrong size on UNavModifierComponent");
static_assert(offsetof(UNavModifierComponent, AreaClass) == 0x0000E0, "Member 'UNavModifierComponent::AreaClass' has a wrong offset!");
static_assert(offsetof(UNavModifierComponent, FailsafeExtent) == 0x0000E8, "Member 'UNavModifierComponent::FailsafeExtent' has a wrong offset!");

// Class NavigationSystem.NavModifierVolume
// 0x0018 (0x0270 - 0x0258)
class ANavModifierVolume final : public AVolume
{
public:
	uint8                                         Pad_258[0x8];                                      // 0x0258(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavArea>                   AreaClass;                                         // 0x0260(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bMaskFillCollisionUnderneathForNavmesh;            // 0x0268(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_269[0x7];                                      // 0x0269(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAreaClass(TSubclassOf<class UNavArea> NewAreaClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavModifierVolume">();
	}
	static class ANavModifierVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavModifierVolume>();
	}
};
static_assert(alignof(ANavModifierVolume) == 0x000008, "Wrong alignment on ANavModifierVolume");
static_assert(sizeof(ANavModifierVolume) == 0x000270, "Wrong size on ANavModifierVolume");
static_assert(offsetof(ANavModifierVolume, AreaClass) == 0x000260, "Member 'ANavModifierVolume::AreaClass' has a wrong offset!");
static_assert(offsetof(ANavModifierVolume, bMaskFillCollisionUnderneathForNavmesh) == 0x000268, "Member 'ANavModifierVolume::bMaskFillCollisionUnderneathForNavmesh' has a wrong offset!");

// Class NavigationSystem.NavNodeInterface
// 0x0000 (0x0000 - 0x0000)
class INavNodeInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavNodeInterface">();
	}
	static class INavNodeInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavNodeInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavNodeInterface) == 0x000001, "Wrong alignment on INavNodeInterface");
static_assert(sizeof(INavNodeInterface) == 0x000001, "Wrong size on INavNodeInterface");

// Class NavigationSystem.NavSystemConfigOverride
// 0x0010 (0x0230 - 0x0220)
class ANavSystemConfigOverride final : public AActor
{
public:
	class UNavigationSystemConfig*                NavigationSystemConfig;                            // 0x0220(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ENavSystemOverridePolicy                      OverridePolicy;                                    // 0x0228(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bLoadOnClient : 1;                                 // 0x0229(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_22A[0x6];                                      // 0x022A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavSystemConfigOverride">();
	}
	static class ANavSystemConfigOverride* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavSystemConfigOverride>();
	}
};
static_assert(alignof(ANavSystemConfigOverride) == 0x000008, "Wrong alignment on ANavSystemConfigOverride");
static_assert(sizeof(ANavSystemConfigOverride) == 0x000230, "Wrong size on ANavSystemConfigOverride");
static_assert(offsetof(ANavSystemConfigOverride, NavigationSystemConfig) == 0x000220, "Member 'ANavSystemConfigOverride::NavigationSystemConfig' has a wrong offset!");
static_assert(offsetof(ANavSystemConfigOverride, OverridePolicy) == 0x000228, "Member 'ANavSystemConfigOverride::OverridePolicy' has a wrong offset!");

// Class NavigationSystem.NavTestRenderingComponent
// 0x0000 (0x0450 - 0x0450)
class UNavTestRenderingComponent final : public UPrimitiveComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavTestRenderingComponent">();
	}
	static class UNavTestRenderingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavTestRenderingComponent>();
	}
};
static_assert(alignof(UNavTestRenderingComponent) == 0x000010, "Wrong alignment on UNavTestRenderingComponent");
static_assert(sizeof(UNavTestRenderingComponent) == 0x000450, "Wrong size on UNavTestRenderingComponent");

// Class NavigationSystem.RecastFilter_UseDefaultArea
// 0x0000 (0x0048 - 0x0048)
class URecastFilter_UseDefaultArea final : public UNavigationQueryFilter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RecastFilter_UseDefaultArea">();
	}
	static class URecastFilter_UseDefaultArea* GetDefaultObj()
	{
		return GetDefaultObjImpl<URecastFilter_UseDefaultArea>();
	}
};
static_assert(alignof(URecastFilter_UseDefaultArea) == 0x000008, "Wrong alignment on URecastFilter_UseDefaultArea");
static_assert(sizeof(URecastFilter_UseDefaultArea) == 0x000048, "Wrong size on URecastFilter_UseDefaultArea");

// Class NavigationSystem.RecastNavMesh
// 0x0098 (0x04C0 - 0x0428)
class ARecastNavMesh final : public ANavigationData
{
public:
	uint8                                         bDrawTriangleEdges : 1;                            // 0x0428(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawPolyEdges : 1;                                // 0x0428(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawFilledPolys : 1;                              // 0x0428(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawNavMeshEdges : 1;                             // 0x0428(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawTileBounds : 1;                               // 0x0428(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawPathCollidingGeometry : 1;                    // 0x0428(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawTileLabels : 1;                               // 0x0428(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawPolygonLabels : 1;                            // 0x0428(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawDefaultPolygonCost : 1;                       // 0x0429(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawPolygonFlags : 1;                             // 0x0429(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawLabelsOnPathNodes : 1;                        // 0x0429(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawNavLinks : 1;                                 // 0x0429(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawFailedNavLinks : 1;                           // 0x0429(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawClusters : 1;                                 // 0x0429(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawOctree : 1;                                   // 0x0429(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawOctreeDetails : 1;                            // 0x0429(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawMarkedForbiddenPolys : 1;                     // 0x042A(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDistinctlyDrawTilesBeingBuilt : 1;                // 0x042A(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_42B[0x1];                                      // 0x042B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DrawOffset;                                        // 0x042C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bFixedTilePoolSize : 1;                            // 0x0430(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_431[0x3];                                      // 0x0431(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         TilePoolSize;                                      // 0x0434(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TileSizeUU;                                        // 0x0438(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CellSize;                                          // 0x043C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CellHeight;                                        // 0x0440(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AgentRadius;                                       // 0x0444(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AgentHeight;                                       // 0x0448(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AgentMaxSlope;                                     // 0x044C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AgentMaxStepHeight;                                // 0x0450(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinRegionArea;                                     // 0x0454(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MergeRegionSize;                                   // 0x0458(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSimplificationError;                            // 0x045C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxSimultaneousTileGenerationJobsCount;            // 0x0460(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TileNumberHardLimit;                               // 0x0464(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PolyRefTileBits;                                   // 0x0468(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PolyRefNavPolyBits;                                // 0x046C(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PolyRefSaltBits;                                   // 0x0470(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NavMeshOriginOffset;                               // 0x0474(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultDrawDistance;                               // 0x0480(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultMaxSearchNodes;                             // 0x0484(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultMaxHierarchicalSearchNodes;                 // 0x0488(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERecastPartitioning                           RegionPartitioning;                                // 0x048C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERecastPartitioning                           LayerPartitioning;                                 // 0x048D(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_48E[0x2];                                      // 0x048E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RegionChunkSplits;                                 // 0x0490(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         LayerChunkSplits;                                  // 0x0494(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSortNavigationAreasByCost : 1;                    // 0x0498(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPerformVoxelFiltering : 1;                        // 0x0498(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMarkLowHeightAreas : 1;                           // 0x0498(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseExtraTopCellWhenMarkingAreas : 1;              // 0x0498(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFilterLowSpanSequences : 1;                       // 0x0498(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFilterLowSpanFromTileCache : 1;                   // 0x0498(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDoFullyAsyncNavDataGathering : 1;                 // 0x0498(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseBetterOffsetsFromCorners : 1;                  // 0x0498(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStoreEmptyTileLayers : 1;                         // 0x0499(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseVirtualFilters : 1;                            // 0x0499(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowNavLinkAsPathEnd : 1;                        // 0x0499(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseVoxelCache : 1;                                // 0x0499(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_49A[0x2];                                      // 0x049A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TileSetUpdateInterval;                             // 0x049C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         HeuristicScale;                                    // 0x04A0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VerticalDeviationFromGroundCompensation;           // 0x04A4(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4A8[0x18];                                     // 0x04A8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RecastNavMesh">();
	}
	static class ARecastNavMesh* GetDefaultObj()
	{
		return GetDefaultObjImpl<ARecastNavMesh>();
	}
};
static_assert(alignof(ARecastNavMesh) == 0x000008, "Wrong alignment on ARecastNavMesh");
static_assert(sizeof(ARecastNavMesh) == 0x0004C0, "Wrong size on ARecastNavMesh");
static_assert(offsetof(ARecastNavMesh, DrawOffset) == 0x00042C, "Member 'ARecastNavMesh::DrawOffset' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, TilePoolSize) == 0x000434, "Member 'ARecastNavMesh::TilePoolSize' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, TileSizeUU) == 0x000438, "Member 'ARecastNavMesh::TileSizeUU' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, CellSize) == 0x00043C, "Member 'ARecastNavMesh::CellSize' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, CellHeight) == 0x000440, "Member 'ARecastNavMesh::CellHeight' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, AgentRadius) == 0x000444, "Member 'ARecastNavMesh::AgentRadius' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, AgentHeight) == 0x000448, "Member 'ARecastNavMesh::AgentHeight' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, AgentMaxSlope) == 0x00044C, "Member 'ARecastNavMesh::AgentMaxSlope' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, AgentMaxStepHeight) == 0x000450, "Member 'ARecastNavMesh::AgentMaxStepHeight' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, MinRegionArea) == 0x000454, "Member 'ARecastNavMesh::MinRegionArea' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, MergeRegionSize) == 0x000458, "Member 'ARecastNavMesh::MergeRegionSize' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, MaxSimplificationError) == 0x00045C, "Member 'ARecastNavMesh::MaxSimplificationError' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, MaxSimultaneousTileGenerationJobsCount) == 0x000460, "Member 'ARecastNavMesh::MaxSimultaneousTileGenerationJobsCount' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, TileNumberHardLimit) == 0x000464, "Member 'ARecastNavMesh::TileNumberHardLimit' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, PolyRefTileBits) == 0x000468, "Member 'ARecastNavMesh::PolyRefTileBits' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, PolyRefNavPolyBits) == 0x00046C, "Member 'ARecastNavMesh::PolyRefNavPolyBits' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, PolyRefSaltBits) == 0x000470, "Member 'ARecastNavMesh::PolyRefSaltBits' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, NavMeshOriginOffset) == 0x000474, "Member 'ARecastNavMesh::NavMeshOriginOffset' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, DefaultDrawDistance) == 0x000480, "Member 'ARecastNavMesh::DefaultDrawDistance' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, DefaultMaxSearchNodes) == 0x000484, "Member 'ARecastNavMesh::DefaultMaxSearchNodes' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, DefaultMaxHierarchicalSearchNodes) == 0x000488, "Member 'ARecastNavMesh::DefaultMaxHierarchicalSearchNodes' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, RegionPartitioning) == 0x00048C, "Member 'ARecastNavMesh::RegionPartitioning' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, LayerPartitioning) == 0x00048D, "Member 'ARecastNavMesh::LayerPartitioning' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, RegionChunkSplits) == 0x000490, "Member 'ARecastNavMesh::RegionChunkSplits' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, LayerChunkSplits) == 0x000494, "Member 'ARecastNavMesh::LayerChunkSplits' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, TileSetUpdateInterval) == 0x00049C, "Member 'ARecastNavMesh::TileSetUpdateInterval' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, HeuristicScale) == 0x0004A0, "Member 'ARecastNavMesh::HeuristicScale' has a wrong offset!");
static_assert(offsetof(ARecastNavMesh, VerticalDeviationFromGroundCompensation) == 0x0004A4, "Member 'ARecastNavMesh::VerticalDeviationFromGroundCompensation' has a wrong offset!");

// Class NavigationSystem.RecastNavMeshDataChunk
// 0x0010 (0x0040 - 0x0030)
class URecastNavMeshDataChunk final : public UNavigationDataChunk
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RecastNavMeshDataChunk">();
	}
	static class URecastNavMeshDataChunk* GetDefaultObj()
	{
		return GetDefaultObjImpl<URecastNavMeshDataChunk>();
	}
};
static_assert(alignof(URecastNavMeshDataChunk) == 0x000008, "Wrong alignment on URecastNavMeshDataChunk");
static_assert(sizeof(URecastNavMeshDataChunk) == 0x000040, "Wrong size on URecastNavMeshDataChunk");

}

