#pragma once

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

// Package: NavPower

#include "Basic.hpp"

#include "AIModule_classes.hpp"
#include "Engine_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "GameplayTags_structs.hpp"
#include "NavPower_structs.hpp"
#include "NavigationSystem_classes.hpp"


namespace SDK
{

// Class NavPower.NavPowerCustomInclusionBoxRenderingComponent
// 0x0000 (0x00B0 - 0x00B0)
class UNavPowerCustomInclusionBoxRenderingComponent final : public UActorComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerCustomInclusionBoxRenderingComponent">();
	}
	static class UNavPowerCustomInclusionBoxRenderingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerCustomInclusionBoxRenderingComponent>();
	}
};
static_assert(alignof(UNavPowerCustomInclusionBoxRenderingComponent) == 0x000008, "Wrong alignment on UNavPowerCustomInclusionBoxRenderingComponent");
static_assert(sizeof(UNavPowerCustomInclusionBoxRenderingComponent) == 0x0000B0, "Wrong size on UNavPowerCustomInclusionBoxRenderingComponent");

// Class NavPower.NavPowerAIController
// 0x0010 (0x0338 - 0x0328)
class ANavPowerAIController : public AAIController
{
public:
	uint8                                         Pad_328[0x8];                                      // 0x0328(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavPowerPathFollowerComponent*         NavPowerPathFollowerComponent;                     // 0x0330(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerAIController">();
	}
	static class ANavPowerAIController* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavPowerAIController>();
	}
};
static_assert(alignof(ANavPowerAIController) == 0x000008, "Wrong alignment on ANavPowerAIController");
static_assert(sizeof(ANavPowerAIController) == 0x000338, "Wrong size on ANavPowerAIController");
static_assert(offsetof(ANavPowerAIController, NavPowerPathFollowerComponent) == 0x000330, "Member 'ANavPowerAIController::NavPowerPathFollowerComponent' has a wrong offset!");

// Class NavPower.NavPowerNavigationTypeDefinition
// 0x0008 (0x0038 - 0x0030)
class UNavPowerNavigationTypeDefinition : public UDataAsset
{
public:
	uint32                                        NavigationTypeId;                                  // 0x0030(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerNavigationTypeDefinition">();
	}
	static class UNavPowerNavigationTypeDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerNavigationTypeDefinition>();
	}
};
static_assert(alignof(UNavPowerNavigationTypeDefinition) == 0x000008, "Wrong alignment on UNavPowerNavigationTypeDefinition");
static_assert(sizeof(UNavPowerNavigationTypeDefinition) == 0x000038, "Wrong size on UNavPowerNavigationTypeDefinition");
static_assert(offsetof(UNavPowerNavigationTypeDefinition, NavigationTypeId) == 0x000030, "Member 'UNavPowerNavigationTypeDefinition::NavigationTypeId' has a wrong offset!");

// Class NavPower.NavPowerAreaDefinition
// 0x0018 (0x0050 - 0x0038)
class UNavPowerAreaDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	float                                         PenaltyMultiplier;                                 // 0x0038(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        Priority;                                          // 0x003C(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 DrawColor;                                         // 0x0040(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDebugDrawOffset;                                  // 0x0044(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTag                           AreaGameplayTag;                                   // 0x0048(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerAreaDefinition">();
	}
	static class UNavPowerAreaDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerAreaDefinition>();
	}
};
static_assert(alignof(UNavPowerAreaDefinition) == 0x000008, "Wrong alignment on UNavPowerAreaDefinition");
static_assert(sizeof(UNavPowerAreaDefinition) == 0x000050, "Wrong size on UNavPowerAreaDefinition");
static_assert(offsetof(UNavPowerAreaDefinition, PenaltyMultiplier) == 0x000038, "Member 'UNavPowerAreaDefinition::PenaltyMultiplier' has a wrong offset!");
static_assert(offsetof(UNavPowerAreaDefinition, Priority) == 0x00003C, "Member 'UNavPowerAreaDefinition::Priority' has a wrong offset!");
static_assert(offsetof(UNavPowerAreaDefinition, DrawColor) == 0x000040, "Member 'UNavPowerAreaDefinition::DrawColor' has a wrong offset!");
static_assert(offsetof(UNavPowerAreaDefinition, bDebugDrawOffset) == 0x000044, "Member 'UNavPowerAreaDefinition::bDebugDrawOffset' has a wrong offset!");
static_assert(offsetof(UNavPowerAreaDefinition, AreaGameplayTag) == 0x000048, "Member 'UNavPowerAreaDefinition::AreaGameplayTag' has a wrong offset!");

// Class NavPower.NavPowerBuildData
// 0x0010 (0x0038 - 0x0028)
class UNavPowerBuildData final : public UPhxMapBuildData
{
public:
	TArray<struct FNavPowerNavigationGraph>       NavGraphs;                                         // 0x0028(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)

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

// Class NavPower.NavPowerCharacterMovementComponent
// 0x0170 (0x0C60 - 0x0AF0)
#pragma pack(push, 0x1)
class alignas(0x10) UNavPowerCharacterMovementComponent : public UCharacterMovementComponent
{
public:
	uint8                                         Pad_AF0[0x18];                                     // 0x0AF0(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bShouldNeverMove;                                  // 0x0B08(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B09[0x3];                                      // 0x0B09(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                DefaultAttachToNavMeshExtent;                      // 0x0B0C(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector                                LandedAttachToNavMeshExtent;                       // 0x0B18(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B24[0xC];                                      // 0x0B24(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	ENavPowerAvoidanceMode                        AvoidanceMode;                                     // 0x0B30(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B31[0x7];                                      // 0x0B31(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNavPowerMoverTune                     MoverTune;                                         // 0x0B38(0x00F8)(Edit, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C30[0x8];                                      // 0x0C30(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ANavPowerSpace*                         DefaultSpace;                                      // 0x0C38(0x0008)(Edit, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C40[0x18];                                     // 0x0C40(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnOverrideSpaceDestroyed();
	void SetOverrideSpace(class ANavPowerSpace* InOverrideSpace);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerCharacterMovementComponent">();
	}
	static class UNavPowerCharacterMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerCharacterMovementComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UNavPowerCharacterMovementComponent) == 0x000010, "Wrong alignment on UNavPowerCharacterMovementComponent");
static_assert(sizeof(UNavPowerCharacterMovementComponent) == 0x000C60, "Wrong size on UNavPowerCharacterMovementComponent");
static_assert(offsetof(UNavPowerCharacterMovementComponent, bShouldNeverMove) == 0x000B08, "Member 'UNavPowerCharacterMovementComponent::bShouldNeverMove' has a wrong offset!");
static_assert(offsetof(UNavPowerCharacterMovementComponent, DefaultAttachToNavMeshExtent) == 0x000B0C, "Member 'UNavPowerCharacterMovementComponent::DefaultAttachToNavMeshExtent' has a wrong offset!");
static_assert(offsetof(UNavPowerCharacterMovementComponent, LandedAttachToNavMeshExtent) == 0x000B18, "Member 'UNavPowerCharacterMovementComponent::LandedAttachToNavMeshExtent' has a wrong offset!");
static_assert(offsetof(UNavPowerCharacterMovementComponent, AvoidanceMode) == 0x000B30, "Member 'UNavPowerCharacterMovementComponent::AvoidanceMode' has a wrong offset!");
static_assert(offsetof(UNavPowerCharacterMovementComponent, MoverTune) == 0x000B38, "Member 'UNavPowerCharacterMovementComponent::MoverTune' has a wrong offset!");
static_assert(offsetof(UNavPowerCharacterMovementComponent, DefaultSpace) == 0x000C38, "Member 'UNavPowerCharacterMovementComponent::DefaultSpace' has a wrong offset!");

// Class NavPower.NavPowerInclusionBox
// 0x0010 (0x0230 - 0x0220)
class ANavPowerInclusionBox : public AActor
{
public:
	class UBoxComponent*                          BoxComponent;                                      // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class ANavPowerSpace*                         Space;                                             // 0x0228(0x0008)(Edit, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

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

// Class NavPower.NavPowerCustomInclusionBox
// 0x0008 (0x0238 - 0x0230)
class ANavPowerCustomInclusionBox final : public ANavPowerInclusionBox
{
public:
	class UNavPowerCustomMeshDefinition*          CustomMeshDefinition;                              // 0x0230(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerCustomInclusionBox">();
	}
	static class ANavPowerCustomInclusionBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavPowerCustomInclusionBox>();
	}
};
static_assert(alignof(ANavPowerCustomInclusionBox) == 0x000008, "Wrong alignment on ANavPowerCustomInclusionBox");
static_assert(sizeof(ANavPowerCustomInclusionBox) == 0x000238, "Wrong size on ANavPowerCustomInclusionBox");
static_assert(offsetof(ANavPowerCustomInclusionBox, CustomMeshDefinition) == 0x000230, "Member 'ANavPowerCustomInclusionBox::CustomMeshDefinition' has a wrong offset!");

// Class NavPower.NavPowerCustomMeshDefinition
// 0x0018 (0x0048 - 0x0030)
class UNavPowerCustomMeshDefinition final : public UDataAsset
{
public:
	class UNavPowerAreaDefinition*                AreaDefinition;                                    // 0x0030(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UNavPowerLayerDefinition*>       LayerDefinitions;                                  // 0x0038(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerCustomMeshDefinition">();
	}
	static class UNavPowerCustomMeshDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerCustomMeshDefinition>();
	}
};
static_assert(alignof(UNavPowerCustomMeshDefinition) == 0x000008, "Wrong alignment on UNavPowerCustomMeshDefinition");
static_assert(sizeof(UNavPowerCustomMeshDefinition) == 0x000048, "Wrong size on UNavPowerCustomMeshDefinition");
static_assert(offsetof(UNavPowerCustomMeshDefinition, AreaDefinition) == 0x000030, "Member 'UNavPowerCustomMeshDefinition::AreaDefinition' has a wrong offset!");
static_assert(offsetof(UNavPowerCustomMeshDefinition, LayerDefinitions) == 0x000038, "Member 'UNavPowerCustomMeshDefinition::LayerDefinitions' has a wrong offset!");

// Class NavPower.NavPowerCustomNavMesh
// 0x0008 (0x0228 - 0x0220)
class ANavPowerCustomNavMesh final : public AActor
{
public:
	class UNavPowerCustomNavMeshComponent*        CustomNavMeshComponent;                            // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

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

// Class NavPower.NavPowerCustomNavMeshComponent
// 0x0010 (0x0500 - 0x04F0)
class UNavPowerCustomNavMeshComponent final : public UStaticMeshComponent
{
public:
	uint8                                         Pad_4E8[0x8];                                      // 0x04E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavPowerCustomMeshDefinition*          CustomMeshDefinition;                              // 0x04F0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4F8[0x8];                                      // 0x04F8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerCustomNavMeshComponent">();
	}
	static class UNavPowerCustomNavMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerCustomNavMeshComponent>();
	}
};
static_assert(alignof(UNavPowerCustomNavMeshComponent) == 0x000010, "Wrong alignment on UNavPowerCustomNavMeshComponent");
static_assert(sizeof(UNavPowerCustomNavMeshComponent) == 0x000500, "Wrong size on UNavPowerCustomNavMeshComponent");
static_assert(offsetof(UNavPowerCustomNavMeshComponent, CustomMeshDefinition) == 0x0004F0, "Member 'UNavPowerCustomNavMeshComponent::CustomMeshDefinition' has a wrong offset!");

// Class NavPower.NavPowerDebugSettings
// 0x0028 (0x0050 - 0x0028)
class UNavPowerDebugSettings final : public UObject
{
public:
	TArray<struct FNavPowerDebugCategory>         DebugCategories;                                   // 0x0028(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	struct FNavPowerDebugFlags                    NavMeshVisualizationFlags;                         // 0x0038(0x0008)(Edit, Config, NoDestructor, Protected, NativeAccessSpecifierProtected)
	float                                         NavMeshVisualizationOffset;                        // 0x0040(0x0004)(Edit, ZeroConstructor, Config, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxDebugNavProbePaths;                             // 0x0044(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxDebugCheckBoxFit;                               // 0x0048(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxDebugCreatePolylinePaths;                       // 0x004C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerDebugSettings">();
	}
	static class UNavPowerDebugSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerDebugSettings>();
	}
};
static_assert(alignof(UNavPowerDebugSettings) == 0x000008, "Wrong alignment on UNavPowerDebugSettings");
static_assert(sizeof(UNavPowerDebugSettings) == 0x000050, "Wrong size on UNavPowerDebugSettings");
static_assert(offsetof(UNavPowerDebugSettings, DebugCategories) == 0x000028, "Member 'UNavPowerDebugSettings::DebugCategories' has a wrong offset!");
static_assert(offsetof(UNavPowerDebugSettings, NavMeshVisualizationFlags) == 0x000038, "Member 'UNavPowerDebugSettings::NavMeshVisualizationFlags' has a wrong offset!");
static_assert(offsetof(UNavPowerDebugSettings, NavMeshVisualizationOffset) == 0x000040, "Member 'UNavPowerDebugSettings::NavMeshVisualizationOffset' has a wrong offset!");
static_assert(offsetof(UNavPowerDebugSettings, MaxDebugNavProbePaths) == 0x000044, "Member 'UNavPowerDebugSettings::MaxDebugNavProbePaths' has a wrong offset!");
static_assert(offsetof(UNavPowerDebugSettings, MaxDebugCheckBoxFit) == 0x000048, "Member 'UNavPowerDebugSettings::MaxDebugCheckBoxFit' has a wrong offset!");
static_assert(offsetof(UNavPowerDebugSettings, MaxDebugCreatePolylinePaths) == 0x00004C, "Member 'UNavPowerDebugSettings::MaxDebugCreatePolylinePaths' has a wrong offset!");

// Class NavPower.NavPowerDemoController
// 0x0000 (0x0338 - 0x0338)
class ANavPowerDemoController final : public ANavPowerAIController
{
public:
	void NavPowerMoveToLocation(const struct FVector& InLocation);

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

// Class NavPower.NavPowerDemoMovementComponent
// 0x0010 (0x0C70 - 0x0C60)
class UNavPowerDemoMovementComponent final : public UNavPowerCharacterMovementComponent
{
public:
	float                                         NavPowerDesiredSpeed;                              // 0x0C58(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         NavPowerStartStopAcceleration;                     // 0x0C5C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         NavPowerCruiseAcceleration;                        // 0x0C60(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         NavPowerPathAcceleration;                          // 0x0C64(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C68[0x8];                                      // 0x0C68(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerDemoMovementComponent">();
	}
	static class UNavPowerDemoMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerDemoMovementComponent>();
	}
};
static_assert(alignof(UNavPowerDemoMovementComponent) == 0x000010, "Wrong alignment on UNavPowerDemoMovementComponent");
static_assert(sizeof(UNavPowerDemoMovementComponent) == 0x000C70, "Wrong size on UNavPowerDemoMovementComponent");
static_assert(offsetof(UNavPowerDemoMovementComponent, NavPowerDesiredSpeed) == 0x000C58, "Member 'UNavPowerDemoMovementComponent::NavPowerDesiredSpeed' has a wrong offset!");
static_assert(offsetof(UNavPowerDemoMovementComponent, NavPowerStartStopAcceleration) == 0x000C5C, "Member 'UNavPowerDemoMovementComponent::NavPowerStartStopAcceleration' has a wrong offset!");
static_assert(offsetof(UNavPowerDemoMovementComponent, NavPowerCruiseAcceleration) == 0x000C60, "Member 'UNavPowerDemoMovementComponent::NavPowerCruiseAcceleration' has a wrong offset!");
static_assert(offsetof(UNavPowerDemoMovementComponent, NavPowerPathAcceleration) == 0x000C64, "Member 'UNavPowerDemoMovementComponent::NavPowerPathAcceleration' has a wrong offset!");

// Class NavPower.NavPowerDemoPawn
// 0x0000 (0x04C0 - 0x04C0)
class ANavPowerDemoPawn final : public ACharacter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerDemoPawn">();
	}
	static class ANavPowerDemoPawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavPowerDemoPawn>();
	}
};
static_assert(alignof(ANavPowerDemoPawn) == 0x000010, "Wrong alignment on ANavPowerDemoPawn");
static_assert(sizeof(ANavPowerDemoPawn) == 0x0004C0, "Wrong size on ANavPowerDemoPawn");

// Class NavPower.NavPowerDynamicObstacleBox
// 0x0008 (0x0228 - 0x0220)
class ANavPowerDynamicObstacleBox final : public AActor
{
public:
	class UNavPowerDynamicObstacleComponent*      DynamicObstacleComponent;                          // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	class UNavPowerDynamicObstacleComponent* GetDynamicObstacleComponent() const;

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

// Class NavPower.NavPowerDynamicObstacleComponent
// 0x0030 (0x04B0 - 0x0480)
class UNavPowerDynamicObstacleComponent final : public UBoxComponent
{
public:
	uint8                                         Pad_478[0x8];                                      // 0x0478(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavPowerObstacleDefinition*            ObstacleDefinition;                                // 0x0480(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bStartEnabled;                                     // 0x0488(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bDestroyObstacleWhenDisabled;                      // 0x0489(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bUpdateObstacleAfterActorMoves;                    // 0x048A(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_48B[0x1];                                      // 0x048B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DistanceMovedToUpdateObstacle;                     // 0x048C(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_490[0x20];                                     // 0x0490(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetEnabled(bool bInEnabled);
	void SetObstacleDefinition(const class UNavPowerObstacleDefinition* NewObstacleDefinition);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerDynamicObstacleComponent">();
	}
	static class UNavPowerDynamicObstacleComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerDynamicObstacleComponent>();
	}
};
static_assert(alignof(UNavPowerDynamicObstacleComponent) == 0x000010, "Wrong alignment on UNavPowerDynamicObstacleComponent");
static_assert(sizeof(UNavPowerDynamicObstacleComponent) == 0x0004B0, "Wrong size on UNavPowerDynamicObstacleComponent");
static_assert(offsetof(UNavPowerDynamicObstacleComponent, ObstacleDefinition) == 0x000480, "Member 'UNavPowerDynamicObstacleComponent::ObstacleDefinition' has a wrong offset!");
static_assert(offsetof(UNavPowerDynamicObstacleComponent, bStartEnabled) == 0x000488, "Member 'UNavPowerDynamicObstacleComponent::bStartEnabled' has a wrong offset!");
static_assert(offsetof(UNavPowerDynamicObstacleComponent, bDestroyObstacleWhenDisabled) == 0x000489, "Member 'UNavPowerDynamicObstacleComponent::bDestroyObstacleWhenDisabled' has a wrong offset!");
static_assert(offsetof(UNavPowerDynamicObstacleComponent, bUpdateObstacleAfterActorMoves) == 0x00048A, "Member 'UNavPowerDynamicObstacleComponent::bUpdateObstacleAfterActorMoves' has a wrong offset!");
static_assert(offsetof(UNavPowerDynamicObstacleComponent, DistanceMovedToUpdateObstacle) == 0x00048C, "Member 'UNavPowerDynamicObstacleComponent::DistanceMovedToUpdateObstacle' has a wrong offset!");

// Class NavPower.NavPowerGhostNavMesh
// 0x0008 (0x0228 - 0x0220)
class ANavPowerGhostNavMesh final : public AActor
{
public:
	class UNavPowerGhostNavMeshComponent*         GhostNavMeshComponent;                             // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

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

// Class NavPower.NavPowerGhostNavMeshComponent
// 0x0000 (0x04F0 - 0x04F0)
class UNavPowerGhostNavMeshComponent final : public UStaticMeshComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerGhostNavMeshComponent">();
	}
	static class UNavPowerGhostNavMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerGhostNavMeshComponent>();
	}
};
static_assert(alignof(UNavPowerGhostNavMeshComponent) == 0x000010, "Wrong alignment on UNavPowerGhostNavMeshComponent");
static_assert(sizeof(UNavPowerGhostNavMeshComponent) == 0x0004F0, "Wrong size on UNavPowerGhostNavMeshComponent");

// Class NavPower.NavPowerIslandCreationMarker
// 0x0008 (0x0228 - 0x0220)
class ANavPowerIslandCreationMarker final : public AActor
{
public:
	uint8                                         Pad_220[0x8];                                      // 0x0220(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

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

// Class NavPower.NavPowerLayerDefinition
// 0x0030 (0x0068 - 0x0038)
class UNavPowerLayerDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	float                                         Radius;                                            // 0x0038(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Height;                                            // 0x003C(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                DefaultQueryExtent;                                // 0x0040(0x000C)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                FallToNavMeshExtent;                               // 0x004C(0x000C)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReachabilityQueryExtent;                           // 0x0058(0x000C)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_64[0x4];                                       // 0x0064(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerLayerDefinition">();
	}
	static class UNavPowerLayerDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerLayerDefinition>();
	}
};
static_assert(alignof(UNavPowerLayerDefinition) == 0x000008, "Wrong alignment on UNavPowerLayerDefinition");
static_assert(sizeof(UNavPowerLayerDefinition) == 0x000068, "Wrong size on UNavPowerLayerDefinition");
static_assert(offsetof(UNavPowerLayerDefinition, Radius) == 0x000038, "Member 'UNavPowerLayerDefinition::Radius' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerDefinition, Height) == 0x00003C, "Member 'UNavPowerLayerDefinition::Height' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerDefinition, DefaultQueryExtent) == 0x000040, "Member 'UNavPowerLayerDefinition::DefaultQueryExtent' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerDefinition, FallToNavMeshExtent) == 0x00004C, "Member 'UNavPowerLayerDefinition::FallToNavMeshExtent' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerDefinition, ReachabilityQueryExtent) == 0x000058, "Member 'UNavPowerLayerDefinition::ReachabilityQueryExtent' has a wrong offset!");

// Class NavPower.NavPowerLayerUserDefinition
// 0x0030 (0x0068 - 0x0038)
class UNavPowerLayerUserDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	float                                         LinkUseDistance;                                   // 0x0038(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowedOnWalls;                                   // 0x003C(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavPowerQueryFilterDefinition*         QueryFilter;                                       // 0x0040(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerQueryFilterDefinitionBase*     ProjectionQueryFilter;                             // 0x0048(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerQueryFilterDefinitionBase*     LandingQueryFilter;                                // 0x0050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerQueryFilterDefinitionBase*     MoveInDirectionQueryFilter;                        // 0x0058(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerLayerDefinition*               Layer;                                             // 0x0060(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerLayerUserDefinition">();
	}
	static class UNavPowerLayerUserDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerLayerUserDefinition>();
	}
};
static_assert(alignof(UNavPowerLayerUserDefinition) == 0x000008, "Wrong alignment on UNavPowerLayerUserDefinition");
static_assert(sizeof(UNavPowerLayerUserDefinition) == 0x000068, "Wrong size on UNavPowerLayerUserDefinition");
static_assert(offsetof(UNavPowerLayerUserDefinition, LinkUseDistance) == 0x000038, "Member 'UNavPowerLayerUserDefinition::LinkUseDistance' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, bAllowedOnWalls) == 0x00003C, "Member 'UNavPowerLayerUserDefinition::bAllowedOnWalls' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, QueryFilter) == 0x000040, "Member 'UNavPowerLayerUserDefinition::QueryFilter' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, ProjectionQueryFilter) == 0x000048, "Member 'UNavPowerLayerUserDefinition::ProjectionQueryFilter' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, LandingQueryFilter) == 0x000050, "Member 'UNavPowerLayerUserDefinition::LandingQueryFilter' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, MoveInDirectionQueryFilter) == 0x000058, "Member 'UNavPowerLayerUserDefinition::MoveInDirectionQueryFilter' has a wrong offset!");
static_assert(offsetof(UNavPowerLayerUserDefinition, Layer) == 0x000060, "Member 'UNavPowerLayerUserDefinition::Layer' has a wrong offset!");

// Class NavPower.NavPowerLink
// 0x0060 (0x0280 - 0x0220)
class ANavPowerLink : public AActor
{
public:
	uint8                                         Pad_220[0x20];                                     // 0x0220(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  EnabledLinkTags;                                   // 0x0240(0x0020)(Edit, DisableEditOnTemplate, Protected, NativeAccessSpecifierProtected)
	TArray<struct FNavPowerPointLink>             PointLinks;                                        // 0x0260(0x0010)(Edit, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FNavPowerSegmentLink>           SegmentLinks;                                      // 0x0270(0x0010)(Edit, ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	void SetEnabled(bool bInEnabled);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerLink">();
	}
	static class ANavPowerLink* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavPowerLink>();
	}
};
static_assert(alignof(ANavPowerLink) == 0x000008, "Wrong alignment on ANavPowerLink");
static_assert(sizeof(ANavPowerLink) == 0x000280, "Wrong size on ANavPowerLink");
static_assert(offsetof(ANavPowerLink, EnabledLinkTags) == 0x000240, "Member 'ANavPowerLink::EnabledLinkTags' has a wrong offset!");
static_assert(offsetof(ANavPowerLink, PointLinks) == 0x000260, "Member 'ANavPowerLink::PointLinks' has a wrong offset!");
static_assert(offsetof(ANavPowerLink, SegmentLinks) == 0x000270, "Member 'ANavPowerLink::SegmentLinks' has a wrong offset!");

// Class NavPower.NavPowerLinkDefinition
// 0x0000 (0x0038 - 0x0038)
class UNavPowerLinkDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerLinkDefinition">();
	}
	static class UNavPowerLinkDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerLinkDefinition>();
	}
};
static_assert(alignof(UNavPowerLinkDefinition) == 0x000008, "Wrong alignment on UNavPowerLinkDefinition");
static_assert(sizeof(UNavPowerLinkDefinition) == 0x000038, "Wrong size on UNavPowerLinkDefinition");

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

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

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

// Class NavPower.NavPowerLinkTraversalDefinition
// 0x0018 (0x0048 - 0x0030)
class UNavPowerLinkTraversalDefinition : public UDataAsset
{
public:
	class UNavPowerLayerUserDefinition*           UserDefinition;                                    // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerLinkDefinition*                LinkDefinition;                                    // 0x0038(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavPowerTraversalDefinition*           TraversalDefinition;                               // 0x0040(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerLinkTraversalDefinition">();
	}
	static class UNavPowerLinkTraversalDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerLinkTraversalDefinition>();
	}
};
static_assert(alignof(UNavPowerLinkTraversalDefinition) == 0x000008, "Wrong alignment on UNavPowerLinkTraversalDefinition");
static_assert(sizeof(UNavPowerLinkTraversalDefinition) == 0x000048, "Wrong size on UNavPowerLinkTraversalDefinition");
static_assert(offsetof(UNavPowerLinkTraversalDefinition, UserDefinition) == 0x000030, "Member 'UNavPowerLinkTraversalDefinition::UserDefinition' has a wrong offset!");
static_assert(offsetof(UNavPowerLinkTraversalDefinition, LinkDefinition) == 0x000038, "Member 'UNavPowerLinkTraversalDefinition::LinkDefinition' has a wrong offset!");
static_assert(offsetof(UNavPowerLinkTraversalDefinition, TraversalDefinition) == 0x000040, "Member 'UNavPowerLinkTraversalDefinition::TraversalDefinition' has a wrong offset!");

// Class NavPower.NavPowerMeshRenderingComponent
// 0x0060 (0x04B0 - 0x0450)
class UNavPowerMeshRenderingComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_450[0x60];                                     // 0x0450(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class NavPower.NavPowerModifierBox
// 0x0008 (0x0228 - 0x0220)
class ANavPowerModifierBox final : public AActor
{
public:
	class UNavPowerModifierComponent*             ModifierComponent;                                 // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	class UNavPowerModifierComponent* GetModifierComponent() const;

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

// Class NavPower.NavPowerModifierComponent
// 0x0020 (0x04A0 - 0x0480)
class UNavPowerModifierComponent final : public UBoxComponent
{
public:
	class UNavPowerAreaDefinition*                AreaDefinition;                                    // 0x0478(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerLayerDefinition*>       LayerDefinitions;                                  // 0x0480(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	bool                                          bOnlyAffectDefaultNavMesh;                         // 0x0490(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_491[0xF];                                      // 0x0491(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerModifierComponent">();
	}
	static class UNavPowerModifierComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerModifierComponent>();
	}
};
static_assert(alignof(UNavPowerModifierComponent) == 0x000010, "Wrong alignment on UNavPowerModifierComponent");
static_assert(sizeof(UNavPowerModifierComponent) == 0x0004A0, "Wrong size on UNavPowerModifierComponent");
static_assert(offsetof(UNavPowerModifierComponent, AreaDefinition) == 0x000478, "Member 'UNavPowerModifierComponent::AreaDefinition' has a wrong offset!");
static_assert(offsetof(UNavPowerModifierComponent, LayerDefinitions) == 0x000480, "Member 'UNavPowerModifierComponent::LayerDefinitions' has a wrong offset!");
static_assert(offsetof(UNavPowerModifierComponent, bOnlyAffectDefaultNavMesh) == 0x000490, "Member 'UNavPowerModifierComponent::bOnlyAffectDefaultNavMesh' has a wrong offset!");

// Class NavPower.NavPowerNavigationData
// 0x00D0 (0x02F0 - 0x0220)
class ANavPowerNavigationData final : public AActor
{
public:
	class UNavPowerMeshRenderingComponent*        RenderingComponent;                                // 0x0220(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UNavPowerLayerUserDefinition*           PreviewUser;                                       // 0x0228(0x0008)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         PreviewLinkIndex;                                  // 0x0230(0x0004)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         PreviewLinkSecondaryIndex;                         // 0x0234(0x0004)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bDrawLinks;                                        // 0x0238(0x0001)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bOverrideDrawLinks;                                // 0x0239(0x0001)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_23A[0xB6];                                     // 0x023A(0x00B6)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerNavigationData">();
	}
	static class ANavPowerNavigationData* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavPowerNavigationData>();
	}
};
static_assert(alignof(ANavPowerNavigationData) == 0x000008, "Wrong alignment on ANavPowerNavigationData");
static_assert(sizeof(ANavPowerNavigationData) == 0x0002F0, "Wrong size on ANavPowerNavigationData");
static_assert(offsetof(ANavPowerNavigationData, RenderingComponent) == 0x000220, "Member 'ANavPowerNavigationData::RenderingComponent' has a wrong offset!");
static_assert(offsetof(ANavPowerNavigationData, PreviewUser) == 0x000228, "Member 'ANavPowerNavigationData::PreviewUser' has a wrong offset!");
static_assert(offsetof(ANavPowerNavigationData, PreviewLinkIndex) == 0x000230, "Member 'ANavPowerNavigationData::PreviewLinkIndex' has a wrong offset!");
static_assert(offsetof(ANavPowerNavigationData, PreviewLinkSecondaryIndex) == 0x000234, "Member 'ANavPowerNavigationData::PreviewLinkSecondaryIndex' has a wrong offset!");
static_assert(offsetof(ANavPowerNavigationData, bDrawLinks) == 0x000238, "Member 'ANavPowerNavigationData::bDrawLinks' has a wrong offset!");
static_assert(offsetof(ANavPowerNavigationData, bOverrideDrawLinks) == 0x000239, "Member 'ANavPowerNavigationData::bOverrideDrawLinks' has a wrong offset!");

// Class NavPower.NavPowerNavigationSystem
// 0x0288 (0x02B0 - 0x0028)
class UNavPowerNavigationSystem final : public UNavigationSystemBase
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class ANavPowerNavigationData*                NavigationData;                                    // 0x0048(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_50[0x260];                                     // 0x0050(0x0260)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static bool K2_GetRandomLocationInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, struct FVector* RandomLocation, const class UNavPowerLayerUserDefinition* LayerUser, const class UNavPowerQueryFilterDefinitionBase* QueryFilter);
	static bool K2_ProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, struct FVector* ProjectedLocation, const class UNavPowerLayerUserDefinition* LayerUser, const class UNavPowerQueryFilterDefinitionBase* QueryFilter, const struct FVector& QueryExtent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerNavigationSystem">();
	}
	static class UNavPowerNavigationSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerNavigationSystem>();
	}
};
static_assert(alignof(UNavPowerNavigationSystem) == 0x000008, "Wrong alignment on UNavPowerNavigationSystem");
static_assert(sizeof(UNavPowerNavigationSystem) == 0x0002B0, "Wrong size on UNavPowerNavigationSystem");
static_assert(offsetof(UNavPowerNavigationSystem, NavigationData) == 0x000048, "Member 'UNavPowerNavigationSystem::NavigationData' has a wrong offset!");

// Class NavPower.NavPowerNavigationSystemModuleConfig
// 0x0000 (0x0040 - 0x0040)
class UNavPowerNavigationSystemModuleConfig final : public UNavigationSystemConfig
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerNavigationSystemModuleConfig">();
	}
	static class UNavPowerNavigationSystemModuleConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerNavigationSystemModuleConfig>();
	}
};
static_assert(alignof(UNavPowerNavigationSystemModuleConfig) == 0x000008, "Wrong alignment on UNavPowerNavigationSystemModuleConfig");
static_assert(sizeof(UNavPowerNavigationSystemModuleConfig) == 0x000040, "Wrong size on UNavPowerNavigationSystemModuleConfig");

// Class NavPower.NavPowerObstacleDefinition
// 0x0028 (0x0060 - 0x0038)
class UNavPowerObstacleDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	TArray<class UNavPowerLayerDefinition*>       LayerDefinitions;                                  // 0x0038(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	ENavPowerObstacleBehavior                     ObstacleBehavior;                                  // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bPassable;                                         // 0x004C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PenaltyMultiplier;                                 // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FColor                                 DrawColor;                                         // 0x0054(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FGameplayTag                           ObstacleGameplayTag;                               // 0x0058(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerObstacleDefinition">();
	}
	static class UNavPowerObstacleDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerObstacleDefinition>();
	}
};
static_assert(alignof(UNavPowerObstacleDefinition) == 0x000008, "Wrong alignment on UNavPowerObstacleDefinition");
static_assert(sizeof(UNavPowerObstacleDefinition) == 0x000060, "Wrong size on UNavPowerObstacleDefinition");
static_assert(offsetof(UNavPowerObstacleDefinition, LayerDefinitions) == 0x000038, "Member 'UNavPowerObstacleDefinition::LayerDefinitions' has a wrong offset!");
static_assert(offsetof(UNavPowerObstacleDefinition, ObstacleBehavior) == 0x000048, "Member 'UNavPowerObstacleDefinition::ObstacleBehavior' has a wrong offset!");
static_assert(offsetof(UNavPowerObstacleDefinition, bPassable) == 0x00004C, "Member 'UNavPowerObstacleDefinition::bPassable' has a wrong offset!");
static_assert(offsetof(UNavPowerObstacleDefinition, PenaltyMultiplier) == 0x000050, "Member 'UNavPowerObstacleDefinition::PenaltyMultiplier' has a wrong offset!");
static_assert(offsetof(UNavPowerObstacleDefinition, DrawColor) == 0x000054, "Member 'UNavPowerObstacleDefinition::DrawColor' has a wrong offset!");
static_assert(offsetof(UNavPowerObstacleDefinition, ObstacleGameplayTag) == 0x000058, "Member 'UNavPowerObstacleDefinition::ObstacleGameplayTag' has a wrong offset!");

// Class NavPower.NavPowerPathFollowerComponent
// 0x0090 (0x0140 - 0x00B0)
class UNavPowerPathFollowerComponent final : public UActorComponent
{
public:
	uint8                                         Pad_B0[0x28];                                      // 0x00B0(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavPowerCharacterMovementComponent*    MovementComp;                                      // 0x00D8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E0[0x60];                                      // 0x00E0(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

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

// Class NavPower.NavPowerQueryFilterDefinitionBase
// 0x0000 (0x0030 - 0x0030)
class UNavPowerQueryFilterDefinitionBase : public UDataAsset
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerQueryFilterDefinitionBase">();
	}
	static class UNavPowerQueryFilterDefinitionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerQueryFilterDefinitionBase>();
	}
};
static_assert(alignof(UNavPowerQueryFilterDefinitionBase) == 0x000008, "Wrong alignment on UNavPowerQueryFilterDefinitionBase");
static_assert(sizeof(UNavPowerQueryFilterDefinitionBase) == 0x000030, "Wrong size on UNavPowerQueryFilterDefinitionBase");

// Class NavPower.NavPowerQueryFilterDefinition
// 0x0038 (0x0068 - 0x0030)
class UNavPowerQueryFilterDefinition final : public UNavPowerQueryFilterDefinitionBase
{
public:
	TArray<struct FNavPowerAreaFilter>            TraversableAreas;                                  // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerObstacleDefinition*>    TraversableObstacles;                              // 0x0040(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerLinkDefinition*>        TraversableLinks;                                  // 0x0050(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	bool                                          bUseTraversalPathSharingPenalty;                   // 0x0060(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerQueryFilterDefinition">();
	}
	static class UNavPowerQueryFilterDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerQueryFilterDefinition>();
	}
};
static_assert(alignof(UNavPowerQueryFilterDefinition) == 0x000008, "Wrong alignment on UNavPowerQueryFilterDefinition");
static_assert(sizeof(UNavPowerQueryFilterDefinition) == 0x000068, "Wrong size on UNavPowerQueryFilterDefinition");
static_assert(offsetof(UNavPowerQueryFilterDefinition, TraversableAreas) == 0x000030, "Member 'UNavPowerQueryFilterDefinition::TraversableAreas' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterDefinition, TraversableObstacles) == 0x000040, "Member 'UNavPowerQueryFilterDefinition::TraversableObstacles' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterDefinition, TraversableLinks) == 0x000050, "Member 'UNavPowerQueryFilterDefinition::TraversableLinks' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterDefinition, bUseTraversalPathSharingPenalty) == 0x000060, "Member 'UNavPowerQueryFilterDefinition::bUseTraversalPathSharingPenalty' has a wrong offset!");

// Class NavPower.NavPowerQueryFilterModifierDefinition
// 0x0068 (0x0098 - 0x0030)
class UNavPowerQueryFilterModifierDefinition final : public UNavPowerQueryFilterDefinitionBase
{
public:
	TArray<struct FNavPowerAreaFilter>            TraversableAreas;                                  // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerObstacleDefinition*>    TraversableObstacles;                              // 0x0040(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerLinkDefinition*>        TraversableLinks;                                  // 0x0050(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerAreaDefinition*>        UntraversableAreas;                                // 0x0060(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerObstacleDefinition*>    UntraversableObstacles;                            // 0x0070(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerLinkDefinition*>        UntraversableLinks;                                // 0x0080(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	bool                                          bUseTraversalPathSharingPenalty;                   // 0x0090(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerQueryFilterModifierDefinition">();
	}
	static class UNavPowerQueryFilterModifierDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerQueryFilterModifierDefinition>();
	}
};
static_assert(alignof(UNavPowerQueryFilterModifierDefinition) == 0x000008, "Wrong alignment on UNavPowerQueryFilterModifierDefinition");
static_assert(sizeof(UNavPowerQueryFilterModifierDefinition) == 0x000098, "Wrong size on UNavPowerQueryFilterModifierDefinition");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, TraversableAreas) == 0x000030, "Member 'UNavPowerQueryFilterModifierDefinition::TraversableAreas' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, TraversableObstacles) == 0x000040, "Member 'UNavPowerQueryFilterModifierDefinition::TraversableObstacles' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, TraversableLinks) == 0x000050, "Member 'UNavPowerQueryFilterModifierDefinition::TraversableLinks' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, UntraversableAreas) == 0x000060, "Member 'UNavPowerQueryFilterModifierDefinition::UntraversableAreas' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, UntraversableObstacles) == 0x000070, "Member 'UNavPowerQueryFilterModifierDefinition::UntraversableObstacles' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, UntraversableLinks) == 0x000080, "Member 'UNavPowerQueryFilterModifierDefinition::UntraversableLinks' has a wrong offset!");
static_assert(offsetof(UNavPowerQueryFilterModifierDefinition, bUseTraversalPathSharingPenalty) == 0x000090, "Member 'UNavPowerQueryFilterModifierDefinition::bUseTraversalPathSharingPenalty' has a wrong offset!");

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

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

// Class NavPower.NavPowerRepulsorDefinition
// 0x0028 (0x0060 - 0x0038)
class UNavPowerRepulsorDefinition final : public UNavPowerNavigationTypeDefinition
{
public:
	float                                         InnerCushion;                                      // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         OuterCushion;                                      // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         Bulk;                                              // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UNavPowerRepulsorDefinition*>    BlockedRepulsors;                                  // 0x0048(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	float                                         RepulsionMultiplier;                               // 0x0058(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerRepulsorDefinition">();
	}
	static class UNavPowerRepulsorDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerRepulsorDefinition>();
	}
};
static_assert(alignof(UNavPowerRepulsorDefinition) == 0x000008, "Wrong alignment on UNavPowerRepulsorDefinition");
static_assert(sizeof(UNavPowerRepulsorDefinition) == 0x000060, "Wrong size on UNavPowerRepulsorDefinition");
static_assert(offsetof(UNavPowerRepulsorDefinition, InnerCushion) == 0x000038, "Member 'UNavPowerRepulsorDefinition::InnerCushion' has a wrong offset!");
static_assert(offsetof(UNavPowerRepulsorDefinition, OuterCushion) == 0x00003C, "Member 'UNavPowerRepulsorDefinition::OuterCushion' has a wrong offset!");
static_assert(offsetof(UNavPowerRepulsorDefinition, Bulk) == 0x000040, "Member 'UNavPowerRepulsorDefinition::Bulk' has a wrong offset!");
static_assert(offsetof(UNavPowerRepulsorDefinition, BlockedRepulsors) == 0x000048, "Member 'UNavPowerRepulsorDefinition::BlockedRepulsors' has a wrong offset!");
static_assert(offsetof(UNavPowerRepulsorDefinition, RepulsionMultiplier) == 0x000058, "Member 'UNavPowerRepulsorDefinition::RepulsionMultiplier' has a wrong offset!");

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

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

// Class NavPower.NavPowerSettings
// 0x0120 (0x0148 - 0x0028)
class UNavPowerSettings final : public UObject
{
public:
	float                                         DefaultAgentHeight;                                // 0x0028(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClientMotion;                                     // 0x002C(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2D[0x3];                                       // 0x002D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxSnapOnCreationDistance;                         // 0x0030(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MaxAttachToNavMeshExtent;                          // 0x0034(0x000C)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowDetour;                                      // 0x0040(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENavPowerPathQualityLevel                     PathQualityLevel;                                  // 0x0041(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bExitPuppetInObstacles;                            // 0x0042(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_43[0x1];                                       // 0x0043(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNavPowerPathCreationSettings          PathCreation;                                      // 0x0044(0x000C)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerAutoObstacleSettings          AutoObstacle;                                      // 0x0050(0x0008)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerProberSettings                Prober;                                            // 0x0058(0x0008)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerRepulsionSettings             Repulsion;                                         // 0x0060(0x001C)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerSurfaceOrientSettings         SurfaceOrient;                                     // 0x007C(0x000C)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerAvoidanceSettings             Avoidance;                                         // 0x0088(0x0010)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	float                                         NavgraphConnectionDist;                            // 0x0098(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxObstacleOverlapsAtSingleLocation;               // 0x009C(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxObstaclesToApplyPerFrame;                       // 0x00A0(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableAggressiveLinkSnapping;                     // 0x00A4(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNavPowerPlayerSettings                PlayerSettings;                                    // 0x00A8(0x0008)(Edit, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FNavPowerRegisteredNavigationTypeDefinitions NavigationTypeDefinitions;                   // 0x00B0(0x0098)(Edit, Config, DisableEditOnInstance, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerSettings">();
	}
	static class UNavPowerSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerSettings>();
	}
};
static_assert(alignof(UNavPowerSettings) == 0x000008, "Wrong alignment on UNavPowerSettings");
static_assert(sizeof(UNavPowerSettings) == 0x000148, "Wrong size on UNavPowerSettings");
static_assert(offsetof(UNavPowerSettings, DefaultAgentHeight) == 0x000028, "Member 'UNavPowerSettings::DefaultAgentHeight' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, bClientMotion) == 0x00002C, "Member 'UNavPowerSettings::bClientMotion' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, MaxSnapOnCreationDistance) == 0x000030, "Member 'UNavPowerSettings::MaxSnapOnCreationDistance' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, MaxAttachToNavMeshExtent) == 0x000034, "Member 'UNavPowerSettings::MaxAttachToNavMeshExtent' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, bAllowDetour) == 0x000040, "Member 'UNavPowerSettings::bAllowDetour' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, PathQualityLevel) == 0x000041, "Member 'UNavPowerSettings::PathQualityLevel' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, bExitPuppetInObstacles) == 0x000042, "Member 'UNavPowerSettings::bExitPuppetInObstacles' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, PathCreation) == 0x000044, "Member 'UNavPowerSettings::PathCreation' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, AutoObstacle) == 0x000050, "Member 'UNavPowerSettings::AutoObstacle' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, Prober) == 0x000058, "Member 'UNavPowerSettings::Prober' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, Repulsion) == 0x000060, "Member 'UNavPowerSettings::Repulsion' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, SurfaceOrient) == 0x00007C, "Member 'UNavPowerSettings::SurfaceOrient' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, Avoidance) == 0x000088, "Member 'UNavPowerSettings::Avoidance' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, NavgraphConnectionDist) == 0x000098, "Member 'UNavPowerSettings::NavgraphConnectionDist' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, MaxObstacleOverlapsAtSingleLocation) == 0x00009C, "Member 'UNavPowerSettings::MaxObstacleOverlapsAtSingleLocation' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, MaxObstaclesToApplyPerFrame) == 0x0000A0, "Member 'UNavPowerSettings::MaxObstaclesToApplyPerFrame' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, bEnableAggressiveLinkSnapping) == 0x0000A4, "Member 'UNavPowerSettings::bEnableAggressiveLinkSnapping' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, PlayerSettings) == 0x0000A8, "Member 'UNavPowerSettings::PlayerSettings' has a wrong offset!");
static_assert(offsetof(UNavPowerSettings, NavigationTypeDefinitions) == 0x0000B0, "Member 'UNavPowerSettings::NavigationTypeDefinitions' has a wrong offset!");

// Class NavPower.NavPowerSpace
// 0x0028 (0x0248 - 0x0220)
class ANavPowerSpace final : public AActor
{
public:
	uint8                                         Pad_220[0x28];                                     // 0x0220(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class NavPower.NavPowerStreamPortal
// 0x0008 (0x0228 - 0x0220)
class ANavPowerStreamPortal final : public AActor
{
public:
	class UNavPowerStreamPortalComponent*         StreamPortalComponent;                             // 0x0220(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

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

// Class NavPower.NavPowerStreamPortalComponent
// 0x0000 (0x0200 - 0x0200)
class UNavPowerStreamPortalComponent final : public USceneComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerStreamPortalComponent">();
	}
	static class UNavPowerStreamPortalComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerStreamPortalComponent>();
	}
};
static_assert(alignof(UNavPowerStreamPortalComponent) == 0x000010, "Wrong alignment on UNavPowerStreamPortalComponent");
static_assert(sizeof(UNavPowerStreamPortalComponent) == 0x000200, "Wrong size on UNavPowerStreamPortalComponent");

// Class NavPower.NavPowerTraversalDefinition
// 0x0048 (0x0078 - 0x0030)
class UNavPowerTraversalDefinition final : public UDataAsset
{
public:
	ENavPowerTraversalPenaltyType                 PenaltyType;                                       // 0x0030(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PenaltyMultiplier;                                 // 0x0034(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FixedPenalty;                                      // 0x0038(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENavPowerTraversalSharedPathPenaltyType       SharedPathPenaltyType;                             // 0x003C(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SharedPathPenaltyMultiplier;                       // 0x0040(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SharedPathFixedPenalty;                            // 0x0044(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSnapDistance;                                   // 0x0048(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldStopToUse;                                  // 0x004C(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSupportsBiDirectionality;                         // 0x004D(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4E[0x2];                                       // 0x004E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UNavPowerAreaDefinition*>        StartAreas;                                        // 0x0050(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPrivate)
	TArray<class UNavPowerAreaDefinition*>        EndAreas;                                          // 0x0060(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPrivate)
	uint8                                         Pad_70[0x8];                                       // 0x0070(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPowerTraversalDefinition">();
	}
	static class UNavPowerTraversalDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavPowerTraversalDefinition>();
	}
};
static_assert(alignof(UNavPowerTraversalDefinition) == 0x000008, "Wrong alignment on UNavPowerTraversalDefinition");
static_assert(sizeof(UNavPowerTraversalDefinition) == 0x000078, "Wrong size on UNavPowerTraversalDefinition");
static_assert(offsetof(UNavPowerTraversalDefinition, PenaltyType) == 0x000030, "Member 'UNavPowerTraversalDefinition::PenaltyType' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, PenaltyMultiplier) == 0x000034, "Member 'UNavPowerTraversalDefinition::PenaltyMultiplier' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, FixedPenalty) == 0x000038, "Member 'UNavPowerTraversalDefinition::FixedPenalty' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, SharedPathPenaltyType) == 0x00003C, "Member 'UNavPowerTraversalDefinition::SharedPathPenaltyType' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, SharedPathPenaltyMultiplier) == 0x000040, "Member 'UNavPowerTraversalDefinition::SharedPathPenaltyMultiplier' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, SharedPathFixedPenalty) == 0x000044, "Member 'UNavPowerTraversalDefinition::SharedPathFixedPenalty' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, MaxSnapDistance) == 0x000048, "Member 'UNavPowerTraversalDefinition::MaxSnapDistance' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, bShouldStopToUse) == 0x00004C, "Member 'UNavPowerTraversalDefinition::bShouldStopToUse' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, bSupportsBiDirectionality) == 0x00004D, "Member 'UNavPowerTraversalDefinition::bSupportsBiDirectionality' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, StartAreas) == 0x000050, "Member 'UNavPowerTraversalDefinition::StartAreas' has a wrong offset!");
static_assert(offsetof(UNavPowerTraversalDefinition, EndAreas) == 0x000060, "Member 'UNavPowerTraversalDefinition::EndAreas' has a wrong offset!");

}

