#pragma once

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

// Package: AIModule

#include "Basic.hpp"

#include "AIModule_structs.hpp"
#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "GameplayTasks_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "GameplayTags_structs.hpp"
#include "NavigationSystem_classes.hpp"


namespace SDK
{

// Class AIModule.EnvQueryNode
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryNode : public UObject
{
public:
	int32                                         VerNum;                                            // 0x0028(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.EnvQueryGenerator
// 0x0020 (0x0050 - 0x0030)
class UEnvQueryGenerator : public UEnvQueryNode
{
public:
	class FString                                 OptionName;                                        // 0x0030(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryItemType>          ItemType;                                          // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoSortTests : 1;                                // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator">();
	}
	static class UEnvQueryGenerator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator>();
	}
};
static_assert(alignof(UEnvQueryGenerator) == 0x000008, "Wrong alignment on UEnvQueryGenerator");
static_assert(sizeof(UEnvQueryGenerator) == 0x000050, "Wrong size on UEnvQueryGenerator");
static_assert(offsetof(UEnvQueryGenerator, OptionName) == 0x000030, "Member 'UEnvQueryGenerator::OptionName' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator, ItemType) == 0x000040, "Member 'UEnvQueryGenerator::ItemType' has a wrong offset!");

// Class AIModule.AIController
// 0x0090 (0x0328 - 0x0298)
class AAIController : public AController
{
public:
	uint8                                         Pad_298[0x38];                                     // 0x0298(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bStartAILogicOnPossess : 1;                        // 0x02D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bStopAILogicOnUnposses : 1;                        // 0x02D0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bLOSflag : 1;                                      // 0x02D0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSkipExtraLOSChecks : 1;                           // 0x02D0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowStrafe : 1;                                  // 0x02D0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWantsPlayerState : 1;                             // 0x02D0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSetControlRotationFromPawnOrientation : 1;        // 0x02D0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2D1[0x7];                                      // 0x02D1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPathFollowingComponent*                PathFollowingComponent;                            // 0x02D8(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBrainComponent*                        BrainComponent;                                    // 0x02E0(0x0008)(BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAIPerceptionComponent*                 PerceptionComponent;                               // 0x02E8(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPawnActionsComponent*                  ActionsComp;                                       // 0x02F0(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBlackboardComponent*                   Blackboard;                                        // 0x02F8(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UGameplayTasksComponent*                CachedGameplayTasksComponent;                      // 0x0300(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UNavigationQueryFilter>     DefaultNavigationFilterClass;                      // 0x0308(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TMulticastInlineDelegate<void(const struct FAIRequestID& RequestID, EPathFollowingResult Result)> ReceiveMoveCompleted; // 0x0310(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_320[0x8];                                      // 0x0320(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClaimTaskResource(TSubclassOf<class UGameplayTaskResource> ResourceClass);
	class UAIPerceptionComponent* GetAIPerceptionComponent();
	void K2_ClearFocus();
	void K2_SetFocalPoint(const struct FVector& FP);
	void K2_SetFocus(class AActor* NewFocus);
	EPathFollowingRequestResult MoveToActor(class AActor* Goal, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bCanStrafe, TSubclassOf<class UNavigationQueryFilter> FilterClass, bool bAllowPartialPath);
	EPathFollowingRequestResult MoveToLocation(const struct FVector& Dest, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bProjectDestinationToNavigation, bool bCanStrafe, TSubclassOf<class UNavigationQueryFilter> FilterClass, bool bAllowPartialPath);
	void OnGameplayTaskResourcesClaimed(const struct FGameplayResourceSet& NewlyClaimed, const struct FGameplayResourceSet& FreshlyReleased);
	void OnUsingBlackBoard(class UBlackboardComponent* BlackboardComp, class UBlackboardData* BlackboardAsset);
	bool RunBehaviorTree(class UBehaviorTree* BTAsset);
	void SetMoveBlockDetection(bool bEnable);
	void SetPathFollowingComponent(class UPathFollowingComponent* NewPFComponent);
	void UnclaimTaskResource(TSubclassOf<class UGameplayTaskResource> ResourceClass);
	bool UseBlackboard(class UBlackboardData* BlackboardAsset, class UBlackboardComponent** BlackboardComponent);

	struct FVector GetFocalPoint() const;
	struct FVector GetFocalPointOnActor(const class AActor* Actor) const;
	class AActor* GetFocusActor() const;
	struct FVector GetImmediateMoveDestination() const;
	EPathFollowingStatus GetMoveStatus() const;
	class UPathFollowingComponent* GetPathFollowingComponent() const;
	bool HasPartialPath() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIController">();
	}
	static class AAIController* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAIController>();
	}
};
static_assert(alignof(AAIController) == 0x000008, "Wrong alignment on AAIController");
static_assert(sizeof(AAIController) == 0x000328, "Wrong size on AAIController");
static_assert(offsetof(AAIController, PathFollowingComponent) == 0x0002D8, "Member 'AAIController::PathFollowingComponent' has a wrong offset!");
static_assert(offsetof(AAIController, BrainComponent) == 0x0002E0, "Member 'AAIController::BrainComponent' has a wrong offset!");
static_assert(offsetof(AAIController, PerceptionComponent) == 0x0002E8, "Member 'AAIController::PerceptionComponent' has a wrong offset!");
static_assert(offsetof(AAIController, ActionsComp) == 0x0002F0, "Member 'AAIController::ActionsComp' has a wrong offset!");
static_assert(offsetof(AAIController, Blackboard) == 0x0002F8, "Member 'AAIController::Blackboard' has a wrong offset!");
static_assert(offsetof(AAIController, CachedGameplayTasksComponent) == 0x000300, "Member 'AAIController::CachedGameplayTasksComponent' has a wrong offset!");
static_assert(offsetof(AAIController, DefaultNavigationFilterClass) == 0x000308, "Member 'AAIController::DefaultNavigationFilterClass' has a wrong offset!");
static_assert(offsetof(AAIController, ReceiveMoveCompleted) == 0x000310, "Member 'AAIController::ReceiveMoveCompleted' has a wrong offset!");

// Class AIModule.BlackboardKeyType
// 0x0008 (0x0030 - 0x0028)
class UBlackboardKeyType : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.BlackboardKeyType_NativeEnum
// 0x0018 (0x0048 - 0x0030)
class UBlackboardKeyType_NativeEnum final : public UBlackboardKeyType
{
public:
	class FString                                 EnumName;                                          // 0x0030(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UEnum*                                  EnumType;                                          // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class AIModule.BrainComponent
// 0x0058 (0x0108 - 0x00B0)
class UBrainComponent : public UActorComponent
{
public:
	uint8                                         Pad_B0[0x8];                                       // 0x00B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UBlackboardComponent*                   BlackboardComp;                                    // 0x00B8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AAIController*                          AIOwner;                                           // 0x00C0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_C8[0x40];                                      // 0x00C8(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RestartLogic();
	void StartLogic();
	void StopLogic(const class FString& Reason);

	bool IsPaused() const;
	bool IsRunning() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BrainComponent">();
	}
	static class UBrainComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBrainComponent>();
	}
};
static_assert(alignof(UBrainComponent) == 0x000008, "Wrong alignment on UBrainComponent");
static_assert(sizeof(UBrainComponent) == 0x000108, "Wrong size on UBrainComponent");
static_assert(offsetof(UBrainComponent, BlackboardComp) == 0x0000B8, "Member 'UBrainComponent::BlackboardComp' has a wrong offset!");
static_assert(offsetof(UBrainComponent, AIOwner) == 0x0000C0, "Member 'UBrainComponent::AIOwner' has a wrong offset!");

// Class AIModule.BlackboardKeyType_Object
// 0x0008 (0x0038 - 0x0030)
class UBlackboardKeyType_Object final : public UBlackboardKeyType
{
public:
	class UClass*                                 BaseClass;                                         // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class AIModule.EnvQueryTest
// 0x01C8 (0x01F8 - 0x0030)
class UEnvQueryTest : public UEnvQueryNode
{
public:
	int32                                         TestOrder;                                         // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvTestPurpose                               TestPurpose;                                       // 0x0034(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 TestComment;                                       // 0x0038(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvTestFilterOperator                        MultipleContextFilterOp;                           // 0x0048(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvTestScoreOperator                         MultipleContextScoreOp;                            // 0x0049(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvTestFilterType                            FilterType;                                        // 0x004A(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4B[0x5];                                       // 0x004B(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAIDataProviderBoolValue               BoolValue;                                         // 0x0050(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              FloatValueMin;                                     // 0x0088(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              FloatValueMax;                                     // 0x00C0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_F8[0x1];                                       // 0x00F8(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EEnvTestScoreEquation                         ScoringEquation;                                   // 0x00F9(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvQueryTestClamping                         ClampMinType;                                      // 0x00FA(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvQueryTestClamping                         ClampMaxType;                                      // 0x00FB(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEQSNormalizationType                         NormalizationType;                                 // 0x00FC(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_FD[0x3];                                       // 0x00FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAIDataProviderFloatValue              ScoreClampMin;                                     // 0x0100(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ScoreClampMax;                                     // 0x0138(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ScoringFactor;                                     // 0x0170(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ReferenceValue;                                    // 0x01A8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	bool                                          bDefineReferenceValue;                             // 0x01E0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E1[0xF];                                      // 0x01E1(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bWorkOnFloatValues : 1;                            // 0x01F0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_1F1[0x7];                                      // 0x01F1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest">();
	}
	static class UEnvQueryTest* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest>();
	}
};
static_assert(alignof(UEnvQueryTest) == 0x000008, "Wrong alignment on UEnvQueryTest");
static_assert(sizeof(UEnvQueryTest) == 0x0001F8, "Wrong size on UEnvQueryTest");
static_assert(offsetof(UEnvQueryTest, TestOrder) == 0x000030, "Member 'UEnvQueryTest::TestOrder' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, TestPurpose) == 0x000034, "Member 'UEnvQueryTest::TestPurpose' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, TestComment) == 0x000038, "Member 'UEnvQueryTest::TestComment' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, MultipleContextFilterOp) == 0x000048, "Member 'UEnvQueryTest::MultipleContextFilterOp' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, MultipleContextScoreOp) == 0x000049, "Member 'UEnvQueryTest::MultipleContextScoreOp' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FilterType) == 0x00004A, "Member 'UEnvQueryTest::FilterType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, BoolValue) == 0x000050, "Member 'UEnvQueryTest::BoolValue' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FloatValueMin) == 0x000088, "Member 'UEnvQueryTest::FloatValueMin' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FloatValueMax) == 0x0000C0, "Member 'UEnvQueryTest::FloatValueMax' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoringEquation) == 0x0000F9, "Member 'UEnvQueryTest::ScoringEquation' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ClampMinType) == 0x0000FA, "Member 'UEnvQueryTest::ClampMinType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ClampMaxType) == 0x0000FB, "Member 'UEnvQueryTest::ClampMaxType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, NormalizationType) == 0x0000FC, "Member 'UEnvQueryTest::NormalizationType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoreClampMin) == 0x000100, "Member 'UEnvQueryTest::ScoreClampMin' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoreClampMax) == 0x000138, "Member 'UEnvQueryTest::ScoreClampMax' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoringFactor) == 0x000170, "Member 'UEnvQueryTest::ScoringFactor' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ReferenceValue) == 0x0001A8, "Member 'UEnvQueryTest::ReferenceValue' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, bDefineReferenceValue) == 0x0001E0, "Member 'UEnvQueryTest::bDefineReferenceValue' has a wrong offset!");

// Class AIModule.AISystem
// 0x00D8 (0x0130 - 0x0058)
class UAISystem : public UAISystemBase
{
public:
	struct FSoftClassPath                         PerceptionSystemClassName;                         // 0x0058(0x0018)(Edit, ZeroConstructor, Config, GlobalConfig, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FSoftClassPath                         HotSpotManagerClassName;                           // 0x0070(0x0018)(Edit, ZeroConstructor, Config, GlobalConfig, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AcceptanceRadius;                                  // 0x0088(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PathfollowingRegularPathPointAcceptanceRadius;     // 0x008C(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PathfollowingNavLinkAcceptanceRadius;              // 0x0090(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFinishMoveOnGoalOverlap;                          // 0x0094(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAcceptPartialPaths;                               // 0x0095(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowStrafing;                                    // 0x0096(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableBTAITasks;                                  // 0x0097(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowControllersAsEQSQuerier;                     // 0x0098(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableDebuggerPlugin;                             // 0x0099(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForgetStaleActors;                                // 0x009A(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAddBlackboardSelfKey;                             // 0x009B(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             DefaultSightCollisionChannel;                      // 0x009C(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9D[0x3];                                       // 0x009D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UBehaviorTreeManager*                   BehaviorTreeManager;                               // 0x00A0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UEnvQueryManager*                       EnvironmentQueryManager;                           // 0x00A8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UAIPerceptionSystem*                    PerceptionSystem;                                  // 0x00B0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UAIAsyncTaskBlueprintProxy*>     AllProxyObjects;                                   // 0x00B8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	class UAIHotSpotManager*                      HotSpotManager;                                    // 0x00C8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UNavLocalGridManager*                   NavLocalGrids;                                     // 0x00D0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_D8[0x58];                                      // 0x00D8(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AIIgnorePlayers();
	void AILoggingVerbose();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISystem">();
	}
	static class UAISystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISystem>();
	}
};
static_assert(alignof(UAISystem) == 0x000008, "Wrong alignment on UAISystem");
static_assert(sizeof(UAISystem) == 0x000130, "Wrong size on UAISystem");
static_assert(offsetof(UAISystem, PerceptionSystemClassName) == 0x000058, "Member 'UAISystem::PerceptionSystemClassName' has a wrong offset!");
static_assert(offsetof(UAISystem, HotSpotManagerClassName) == 0x000070, "Member 'UAISystem::HotSpotManagerClassName' has a wrong offset!");
static_assert(offsetof(UAISystem, AcceptanceRadius) == 0x000088, "Member 'UAISystem::AcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, PathfollowingRegularPathPointAcceptanceRadius) == 0x00008C, "Member 'UAISystem::PathfollowingRegularPathPointAcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, PathfollowingNavLinkAcceptanceRadius) == 0x000090, "Member 'UAISystem::PathfollowingNavLinkAcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, bFinishMoveOnGoalOverlap) == 0x000094, "Member 'UAISystem::bFinishMoveOnGoalOverlap' has a wrong offset!");
static_assert(offsetof(UAISystem, bAcceptPartialPaths) == 0x000095, "Member 'UAISystem::bAcceptPartialPaths' has a wrong offset!");
static_assert(offsetof(UAISystem, bAllowStrafing) == 0x000096, "Member 'UAISystem::bAllowStrafing' has a wrong offset!");
static_assert(offsetof(UAISystem, bEnableBTAITasks) == 0x000097, "Member 'UAISystem::bEnableBTAITasks' has a wrong offset!");
static_assert(offsetof(UAISystem, bAllowControllersAsEQSQuerier) == 0x000098, "Member 'UAISystem::bAllowControllersAsEQSQuerier' has a wrong offset!");
static_assert(offsetof(UAISystem, bEnableDebuggerPlugin) == 0x000099, "Member 'UAISystem::bEnableDebuggerPlugin' has a wrong offset!");
static_assert(offsetof(UAISystem, bForgetStaleActors) == 0x00009A, "Member 'UAISystem::bForgetStaleActors' has a wrong offset!");
static_assert(offsetof(UAISystem, bAddBlackboardSelfKey) == 0x00009B, "Member 'UAISystem::bAddBlackboardSelfKey' has a wrong offset!");
static_assert(offsetof(UAISystem, DefaultSightCollisionChannel) == 0x00009C, "Member 'UAISystem::DefaultSightCollisionChannel' has a wrong offset!");
static_assert(offsetof(UAISystem, BehaviorTreeManager) == 0x0000A0, "Member 'UAISystem::BehaviorTreeManager' has a wrong offset!");
static_assert(offsetof(UAISystem, EnvironmentQueryManager) == 0x0000A8, "Member 'UAISystem::EnvironmentQueryManager' has a wrong offset!");
static_assert(offsetof(UAISystem, PerceptionSystem) == 0x0000B0, "Member 'UAISystem::PerceptionSystem' has a wrong offset!");
static_assert(offsetof(UAISystem, AllProxyObjects) == 0x0000B8, "Member 'UAISystem::AllProxyObjects' has a wrong offset!");
static_assert(offsetof(UAISystem, HotSpotManager) == 0x0000C8, "Member 'UAISystem::HotSpotManager' has a wrong offset!");
static_assert(offsetof(UAISystem, NavLocalGrids) == 0x0000D0, "Member 'UAISystem::NavLocalGrids' has a wrong offset!");

// Class AIModule.AISenseConfig
// 0x0020 (0x0048 - 0x0028)
class UAISenseConfig : public UObject
{
public:
	struct FColor                                 DebugColor;                                        // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MaxAge;                                            // 0x002C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bStartsEnabled : 1;                                // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_31[0x17];                                      // 0x0031(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISenseConfig">();
	}
	static class UAISenseConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISenseConfig>();
	}
};
static_assert(alignof(UAISenseConfig) == 0x000008, "Wrong alignment on UAISenseConfig");
static_assert(sizeof(UAISenseConfig) == 0x000048, "Wrong size on UAISenseConfig");
static_assert(offsetof(UAISenseConfig, DebugColor) == 0x000028, "Member 'UAISenseConfig::DebugColor' has a wrong offset!");
static_assert(offsetof(UAISenseConfig, MaxAge) == 0x00002C, "Member 'UAISenseConfig::MaxAge' has a wrong offset!");

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

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

// Class AIModule.PathFollowingComponent
// 0x01A0 (0x0250 - 0x00B0)
class UPathFollowingComponent : public UActorComponent
{
public:
	uint8                                         Pad_B0[0x38];                                      // 0x00B0(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavMovementComponent*                  MovementComp;                                      // 0x00E8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_F0[0x8];                                       // 0x00F0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ANavigationData*                        MyNavData;                                         // 0x00F8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_100[0x150];                                    // 0x0100(0x0150)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnActorBump(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit);
	void OnNavDataRegistered(class ANavigationData* NavData);

	EPathFollowingAction GetPathActionType() const;
	struct FVector GetPathDestination() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PathFollowingComponent">();
	}
	static class UPathFollowingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPathFollowingComponent>();
	}
};
static_assert(alignof(UPathFollowingComponent) == 0x000008, "Wrong alignment on UPathFollowingComponent");
static_assert(sizeof(UPathFollowingComponent) == 0x000250, "Wrong size on UPathFollowingComponent");
static_assert(offsetof(UPathFollowingComponent, MovementComp) == 0x0000E8, "Member 'UPathFollowingComponent::MovementComp' has a wrong offset!");
static_assert(offsetof(UPathFollowingComponent, MyNavData) == 0x0000F8, "Member 'UPathFollowingComponent::MyNavData' has a wrong offset!");

// Class AIModule.CrowdFollowingComponent
// 0x0048 (0x0298 - 0x0250)
class UCrowdFollowingComponent final : public UPathFollowingComponent
{
public:
	uint8                                         Pad_250[0x18];                                     // 0x0250(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                CrowdAgentMoveDirection;                           // 0x0268(0x000C)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_274[0x24];                                     // 0x0274(0x0024)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SuspendCrowdSteering(bool bSuspend);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CrowdFollowingComponent">();
	}
	static class UCrowdFollowingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCrowdFollowingComponent>();
	}
};
static_assert(alignof(UCrowdFollowingComponent) == 0x000008, "Wrong alignment on UCrowdFollowingComponent");
static_assert(sizeof(UCrowdFollowingComponent) == 0x000298, "Wrong size on UCrowdFollowingComponent");
static_assert(offsetof(UCrowdFollowingComponent, CrowdAgentMoveDirection) == 0x000268, "Member 'UCrowdFollowingComponent::CrowdAgentMoveDirection' has a wrong offset!");

// Class AIModule.BehaviorTreeComponent
// 0x0190 (0x0298 - 0x0108)
class UBehaviorTreeComponent : public UBrainComponent
{
public:
	uint8                                         Pad_108[0x20];                                     // 0x0108(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UBTNode*>                        NodeInstances;                                     // 0x0128(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_138[0x140];                                    // 0x0138(0x0140)(Fixing Size After Last Property [ Dumper-7 ])
	class UBehaviorTree*                          DefaultBehaviorTreeAsset;                          // 0x0278(0x0008)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_280[0x18];                                     // 0x0280(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddCooldownTagDuration(const struct FGameplayTag& CooldownTag, float CooldownDuration, bool bAddToExistingDuration);
	void SetDynamicSubtree(const struct FGameplayTag& InjectTag, class UBehaviorTree* BehaviorAsset);

	float GetTagCooldownEndTime(const struct FGameplayTag& CooldownTag) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BehaviorTreeComponent">();
	}
	static class UBehaviorTreeComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBehaviorTreeComponent>();
	}
};
static_assert(alignof(UBehaviorTreeComponent) == 0x000008, "Wrong alignment on UBehaviorTreeComponent");
static_assert(sizeof(UBehaviorTreeComponent) == 0x000298, "Wrong size on UBehaviorTreeComponent");
static_assert(offsetof(UBehaviorTreeComponent, NodeInstances) == 0x000128, "Member 'UBehaviorTreeComponent::NodeInstances' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeComponent, DefaultBehaviorTreeAsset) == 0x000278, "Member 'UBehaviorTreeComponent::DefaultBehaviorTreeAsset' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_ProjectedPoints
// 0x0030 (0x0080 - 0x0050)
class UEnvQueryGenerator_ProjectedPoints : public UEnvQueryGenerator
{
public:
	struct FEnvTraceData                          ProjectionData;                                    // 0x0050(0x0030)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_ProjectedPoints">();
	}
	static class UEnvQueryGenerator_ProjectedPoints* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_ProjectedPoints>();
	}
};
static_assert(alignof(UEnvQueryGenerator_ProjectedPoints) == 0x000008, "Wrong alignment on UEnvQueryGenerator_ProjectedPoints");
static_assert(sizeof(UEnvQueryGenerator_ProjectedPoints) == 0x000080, "Wrong size on UEnvQueryGenerator_ProjectedPoints");
static_assert(offsetof(UEnvQueryGenerator_ProjectedPoints, ProjectionData) == 0x000050, "Member 'UEnvQueryGenerator_ProjectedPoints::ProjectionData' has a wrong offset!");

// Class AIModule.BlackboardAssetProvider
// 0x0000 (0x0000 - 0x0000)
class IBlackboardAssetProvider final
{
public:
	class UBlackboardData* GetBlackboardAsset() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlackboardAssetProvider">();
	}
	static class IBlackboardAssetProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IBlackboardAssetProvider>();
	}

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

// Class AIModule.EnvQueryGenerator_Donut
// 0x0150 (0x01D0 - 0x0080)
class UEnvQueryGenerator_Donut : public UEnvQueryGenerator_ProjectedPoints
{
public:
	struct FAIDataProviderFloatValue              InnerRadius;                                       // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              OuterRadius;                                       // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderIntValue                NumberOfRings;                                     // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderIntValue                PointsPerRing;                                     // 0x0128(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FEnvDirection                          ArcDirection;                                      // 0x0160(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ArcAngle;                                          // 0x0180(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	bool                                          bUseSpiralPattern;                                 // 0x01B8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B9[0x7];                                      // 0x01B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryContext>           Center;                                            // 0x01C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDefineArc : 1;                                    // 0x01C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1C9[0x7];                                      // 0x01C9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_Donut">();
	}
	static class UEnvQueryGenerator_Donut* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_Donut>();
	}
};
static_assert(alignof(UEnvQueryGenerator_Donut) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Donut");
static_assert(sizeof(UEnvQueryGenerator_Donut) == 0x0001D0, "Wrong size on UEnvQueryGenerator_Donut");
static_assert(offsetof(UEnvQueryGenerator_Donut, InnerRadius) == 0x000080, "Member 'UEnvQueryGenerator_Donut::InnerRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, OuterRadius) == 0x0000B8, "Member 'UEnvQueryGenerator_Donut::OuterRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, NumberOfRings) == 0x0000F0, "Member 'UEnvQueryGenerator_Donut::NumberOfRings' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, PointsPerRing) == 0x000128, "Member 'UEnvQueryGenerator_Donut::PointsPerRing' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, ArcDirection) == 0x000160, "Member 'UEnvQueryGenerator_Donut::ArcDirection' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, ArcAngle) == 0x000180, "Member 'UEnvQueryGenerator_Donut::ArcAngle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, bUseSpiralPattern) == 0x0001B8, "Member 'UEnvQueryGenerator_Donut::bUseSpiralPattern' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, Center) == 0x0001C0, "Member 'UEnvQueryGenerator_Donut::Center' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_Cone
// 0x00F0 (0x0170 - 0x0080)
class UEnvQueryGenerator_Cone final : public UEnvQueryGenerator_ProjectedPoints
{
public:
	struct FAIDataProviderFloatValue              AlignedPointsDistance;                             // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FAIDataProviderFloatValue              ConeDegrees;                                       // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FAIDataProviderFloatValue              AngleStep;                                         // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FAIDataProviderFloatValue              Range;                                             // 0x0128(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	TSubclassOf<class UEnvQueryContext>           CenterActor;                                       // 0x0160(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bIncludeContextLocation : 1;                       // 0x0168(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_169[0x7];                                      // 0x0169(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_Cone">();
	}
	static class UEnvQueryGenerator_Cone* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_Cone>();
	}
};
static_assert(alignof(UEnvQueryGenerator_Cone) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Cone");
static_assert(sizeof(UEnvQueryGenerator_Cone) == 0x000170, "Wrong size on UEnvQueryGenerator_Cone");
static_assert(offsetof(UEnvQueryGenerator_Cone, AlignedPointsDistance) == 0x000080, "Member 'UEnvQueryGenerator_Cone::AlignedPointsDistance' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, ConeDegrees) == 0x0000B8, "Member 'UEnvQueryGenerator_Cone::ConeDegrees' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, AngleStep) == 0x0000F0, "Member 'UEnvQueryGenerator_Cone::AngleStep' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, Range) == 0x000128, "Member 'UEnvQueryGenerator_Cone::Range' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, CenterActor) == 0x000160, "Member 'UEnvQueryGenerator_Cone::CenterActor' has a wrong offset!");

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

// Class AIModule.AIDataProvider_QueryParams
// 0x0018 (0x0040 - 0x0028)
class UAIDataProvider_QueryParams : public UAIDataProvider
{
public:
	class FName                                   ParamName;                                         // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FloatValue;                                        // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         IntValue;                                          // 0x0034(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          BoolValue;                                         // 0x0038(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIDataProvider_QueryParams">();
	}
	static class UAIDataProvider_QueryParams* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAIDataProvider_QueryParams>();
	}
};
static_assert(alignof(UAIDataProvider_QueryParams) == 0x000008, "Wrong alignment on UAIDataProvider_QueryParams");
static_assert(sizeof(UAIDataProvider_QueryParams) == 0x000040, "Wrong size on UAIDataProvider_QueryParams");
static_assert(offsetof(UAIDataProvider_QueryParams, ParamName) == 0x000028, "Member 'UAIDataProvider_QueryParams::ParamName' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, FloatValue) == 0x000030, "Member 'UAIDataProvider_QueryParams::FloatValue' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, IntValue) == 0x000034, "Member 'UAIDataProvider_QueryParams::IntValue' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, BoolValue) == 0x000038, "Member 'UAIDataProvider_QueryParams::BoolValue' has a wrong offset!");

// Class AIModule.BTNode
// 0x0030 (0x0058 - 0x0028)
class UBTNode : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 NodeName;                                          // 0x0030(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBehaviorTree*                          TreeAsset;                                         // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBTCompositeNode*                       ParentNode;                                        // 0x0048(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_50[0x8];                                       // 0x0050(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTNode">();
	}
	static class UBTNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTNode>();
	}
};
static_assert(alignof(UBTNode) == 0x000008, "Wrong alignment on UBTNode");
static_assert(sizeof(UBTNode) == 0x000058, "Wrong size on UBTNode");
static_assert(offsetof(UBTNode, NodeName) == 0x000030, "Member 'UBTNode::NodeName' has a wrong offset!");
static_assert(offsetof(UBTNode, TreeAsset) == 0x000040, "Member 'UBTNode::TreeAsset' has a wrong offset!");
static_assert(offsetof(UBTNode, ParentNode) == 0x000048, "Member 'UBTNode::ParentNode' has a wrong offset!");

// Class AIModule.AIAsyncTaskBlueprintProxy
// 0x0040 (0x0068 - 0x0028)
class UAIAsyncTaskBlueprintProxy final : public UObject
{
public:
	TMulticastInlineDelegate<void(EPathFollowingResult MovementResult)> OnSuccess;                   // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(EPathFollowingResult MovementResult)> OnFail;                      // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0x20];                                      // 0x0048(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnMoveCompleted(const struct FAIRequestID& RequestID, EPathFollowingResult MovementResult);

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

// Class AIModule.BTAuxiliaryNode
// 0x0008 (0x0060 - 0x0058)
class UBTAuxiliaryNode : public UBTNode
{
public:
	uint8                                         Pad_58[0x8];                                       // 0x0058(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.BTDecorator
// 0x0008 (0x0068 - 0x0060)
class UBTDecorator : public UBTAuxiliaryNode
{
public:
	uint8                                         BitPad_60_0 : 7;                                   // 0x0060(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bInverseCondition : 1;                             // 0x0060(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_61[0x3];                                       // 0x0061(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EBTFlowAbortMode                              FlowAbortMode;                                     // 0x0064(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_65[0x3];                                       // 0x0065(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator">();
	}
	static class UBTDecorator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator>();
	}
};
static_assert(alignof(UBTDecorator) == 0x000008, "Wrong alignment on UBTDecorator");
static_assert(sizeof(UBTDecorator) == 0x000068, "Wrong size on UBTDecorator");
static_assert(offsetof(UBTDecorator, FlowAbortMode) == 0x000064, "Member 'UBTDecorator::FlowAbortMode' has a wrong offset!");

// Class AIModule.BTDecorator_CompareBBEntries
// 0x0058 (0x00C0 - 0x0068)
class UBTDecorator_CompareBBEntries final : public UBTDecorator
{
public:
	EBlackBoardEntryComparison                    Operator;                                          // 0x0068(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBlackboardKeySelector                 BlackboardKeyA;                                    // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
	struct FBlackboardKeySelector                 BlackboardKeyB;                                    // 0x0098(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_CompareBBEntries">();
	}
	static class UBTDecorator_CompareBBEntries* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_CompareBBEntries>();
	}
};
static_assert(alignof(UBTDecorator_CompareBBEntries) == 0x000008, "Wrong alignment on UBTDecorator_CompareBBEntries");
static_assert(sizeof(UBTDecorator_CompareBBEntries) == 0x0000C0, "Wrong size on UBTDecorator_CompareBBEntries");
static_assert(offsetof(UBTDecorator_CompareBBEntries, Operator) == 0x000068, "Member 'UBTDecorator_CompareBBEntries::Operator' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CompareBBEntries, BlackboardKeyA) == 0x000070, "Member 'UBTDecorator_CompareBBEntries::BlackboardKeyA' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CompareBBEntries, BlackboardKeyB) == 0x000098, "Member 'UBTDecorator_CompareBBEntries::BlackboardKeyB' has a wrong offset!");

// Class AIModule.BTTaskNode
// 0x0018 (0x0070 - 0x0058)
class UBTTaskNode : public UBTNode
{
public:
	TArray<class UBTService*>                     Services;                                          // 0x0058(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bIgnoreRestartSelf : 1;                            // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTaskNode">();
	}
	static class UBTTaskNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTaskNode>();
	}
};
static_assert(alignof(UBTTaskNode) == 0x000008, "Wrong alignment on UBTTaskNode");
static_assert(sizeof(UBTTaskNode) == 0x000070, "Wrong size on UBTTaskNode");
static_assert(offsetof(UBTTaskNode, Services) == 0x000058, "Member 'UBTTaskNode::Services' has a wrong offset!");

// Class AIModule.BTTask_Wait
// 0x0008 (0x0078 - 0x0070)
class UBTTask_Wait : public UBTTaskNode
{
public:
	float                                         WaitTime;                                          // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RandomDeviation;                                   // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_Wait">();
	}
	static class UBTTask_Wait* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_Wait>();
	}
};
static_assert(alignof(UBTTask_Wait) == 0x000008, "Wrong alignment on UBTTask_Wait");
static_assert(sizeof(UBTTask_Wait) == 0x000078, "Wrong size on UBTTask_Wait");
static_assert(offsetof(UBTTask_Wait, WaitTime) == 0x000070, "Member 'UBTTask_Wait::WaitTime' has a wrong offset!");
static_assert(offsetof(UBTTask_Wait, RandomDeviation) == 0x000074, "Member 'UBTTask_Wait::RandomDeviation' has a wrong offset!");

// Class AIModule.BTTask_WaitBlackboardTime
// 0x0028 (0x00A0 - 0x0078)
class UBTTask_WaitBlackboardTime final : public UBTTask_Wait
{
public:
	struct FBlackboardKeySelector                 BlackboardKey;                                     // 0x0078(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_WaitBlackboardTime">();
	}
	static class UBTTask_WaitBlackboardTime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_WaitBlackboardTime>();
	}
};
static_assert(alignof(UBTTask_WaitBlackboardTime) == 0x000008, "Wrong alignment on UBTTask_WaitBlackboardTime");
static_assert(sizeof(UBTTask_WaitBlackboardTime) == 0x0000A0, "Wrong size on UBTTask_WaitBlackboardTime");
static_assert(offsetof(UBTTask_WaitBlackboardTime, BlackboardKey) == 0x000078, "Member 'UBTTask_WaitBlackboardTime::BlackboardKey' has a wrong offset!");

// Class AIModule.BTCompositeNode
// 0x0038 (0x0090 - 0x0058)
class UBTCompositeNode : public UBTNode
{
public:
	TArray<struct FBTCompositeChild>              Children;                                          // 0x0058(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UBTService*>                     Services;                                          // 0x0068(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x10];                                      // 0x0078(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bApplyDecoratorScope : 1;                          // 0x0088(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_89[0x7];                                       // 0x0089(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTCompositeNode">();
	}
	static class UBTCompositeNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTCompositeNode>();
	}
};
static_assert(alignof(UBTCompositeNode) == 0x000008, "Wrong alignment on UBTCompositeNode");
static_assert(sizeof(UBTCompositeNode) == 0x000090, "Wrong size on UBTCompositeNode");
static_assert(offsetof(UBTCompositeNode, Children) == 0x000058, "Member 'UBTCompositeNode::Children' has a wrong offset!");
static_assert(offsetof(UBTCompositeNode, Services) == 0x000068, "Member 'UBTCompositeNode::Services' has a wrong offset!");

// Class AIModule.AISense
// 0x0058 (0x0080 - 0x0028)
class UAISense : public UObject
{
public:
	float                                         DefaultExpirationAge;                              // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EAISenseNotifyType                            NotifyType;                                        // 0x002C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2D[0x3];                                       // 0x002D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bWantsNewPawnNotification : 1;                     // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAutoRegisterAllPawnsAsSources : 1;                // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAIPerceptionSystem*                    PerceptionSystemInstance;                          // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_40[0x40];                                      // 0x0040(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.AISense_Team
// 0x0010 (0x0090 - 0x0080)
class UAISense_Team final : public UAISense
{
public:
	TArray<struct FAITeamStimulusEvent>           RegisteredEvents;                                  // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

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

// Class AIModule.BTDecorator_BlackboardBase
// 0x0028 (0x0090 - 0x0068)
class UBTDecorator_BlackboardBase : public UBTDecorator
{
public:
	struct FBlackboardKeySelector                 BlackboardKey;                                     // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_BlackboardBase">();
	}
	static class UBTDecorator_BlackboardBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_BlackboardBase>();
	}
};
static_assert(alignof(UBTDecorator_BlackboardBase) == 0x000008, "Wrong alignment on UBTDecorator_BlackboardBase");
static_assert(sizeof(UBTDecorator_BlackboardBase) == 0x000090, "Wrong size on UBTDecorator_BlackboardBase");
static_assert(offsetof(UBTDecorator_BlackboardBase, BlackboardKey) == 0x000068, "Member 'UBTDecorator_BlackboardBase::BlackboardKey' has a wrong offset!");

// Class AIModule.AISenseConfig_Damage
// 0x0008 (0x0050 - 0x0048)
class UAISenseConfig_Damage final : public UAISenseConfig
{
public:
	TSubclassOf<class UAISense_Damage>            Implementation;                                    // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class AIModule.EnvQueryTest_Pathfinding
// 0x0088 (0x0280 - 0x01F8)
class UEnvQueryTest_Pathfinding : public UEnvQueryTest
{
public:
	EEnvTestPathfinding                           TestMode;                                          // 0x01F8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F9[0x7];                                      // 0x01F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryContext>           Context;                                           // 0x0200(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIDataProviderBoolValue               PathFromContext;                                   // 0x0208(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderBoolValue               SkipUnreachable;                                   // 0x0240(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavigationQueryFilter>     FilterClass;                                       // 0x0278(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Pathfinding">();
	}
	static class UEnvQueryTest_Pathfinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Pathfinding>();
	}
};
static_assert(alignof(UEnvQueryTest_Pathfinding) == 0x000008, "Wrong alignment on UEnvQueryTest_Pathfinding");
static_assert(sizeof(UEnvQueryTest_Pathfinding) == 0x000280, "Wrong size on UEnvQueryTest_Pathfinding");
static_assert(offsetof(UEnvQueryTest_Pathfinding, TestMode) == 0x0001F8, "Member 'UEnvQueryTest_Pathfinding::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, Context) == 0x000200, "Member 'UEnvQueryTest_Pathfinding::Context' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, PathFromContext) == 0x000208, "Member 'UEnvQueryTest_Pathfinding::PathFromContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, SkipUnreachable) == 0x000240, "Member 'UEnvQueryTest_Pathfinding::SkipUnreachable' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, FilterClass) == 0x000278, "Member 'UEnvQueryTest_Pathfinding::FilterClass' has a wrong offset!");

// Class AIModule.BTDecorator_TimeLimit
// 0x0008 (0x0070 - 0x0068)
class UBTDecorator_TimeLimit : public UBTDecorator
{
public:
	float                                         TimeLimit;                                         // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_TimeLimit">();
	}
	static class UBTDecorator_TimeLimit* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_TimeLimit>();
	}
};
static_assert(alignof(UBTDecorator_TimeLimit) == 0x000008, "Wrong alignment on UBTDecorator_TimeLimit");
static_assert(sizeof(UBTDecorator_TimeLimit) == 0x000070, "Wrong size on UBTDecorator_TimeLimit");
static_assert(offsetof(UBTDecorator_TimeLimit, TimeLimit) == 0x000068, "Member 'UBTDecorator_TimeLimit::TimeLimit' has a wrong offset!");

// Class AIModule.BTService
// 0x0010 (0x0070 - 0x0060)
class UBTService : public UBTAuxiliaryNode
{
public:
	float                                         Interval;                                          // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         RandomDeviation;                                   // 0x0064(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bCallTickOnSearchStart : 1;                        // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bRestartTimerOnEachActivation : 1;                 // 0x0068(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTService">();
	}
	static class UBTService* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTService>();
	}
};
static_assert(alignof(UBTService) == 0x000008, "Wrong alignment on UBTService");
static_assert(sizeof(UBTService) == 0x000070, "Wrong size on UBTService");
static_assert(offsetof(UBTService, Interval) == 0x000060, "Member 'UBTService::Interval' has a wrong offset!");
static_assert(offsetof(UBTService, RandomDeviation) == 0x000064, "Member 'UBTService::RandomDeviation' has a wrong offset!");

// Class AIModule.AITask
// 0x0008 (0x0070 - 0x0068)
class UAITask : public UGameplayTask
{
public:
	class AAIController*                          OwnerController;                                   // 0x0068(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AITask">();
	}
	static class UAITask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAITask>();
	}
};
static_assert(alignof(UAITask) == 0x000008, "Wrong alignment on UAITask");
static_assert(sizeof(UAITask) == 0x000070, "Wrong size on UAITask");
static_assert(offsetof(UAITask, OwnerController) == 0x000068, "Member 'UAITask::OwnerController' has a wrong offset!");

// Class AIModule.AITask_RunEQS
// 0x0078 (0x00E8 - 0x0070)
class UAITask_RunEQS final : public UAITask
{
public:
	uint8                                         Pad_70[0x78];                                      // 0x0070(0x0078)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAITask_RunEQS* RunEQS(class AAIController* Controller, class UEnvQuery* QueryTemplate);

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

// Class AIModule.BTTask_GameplayTaskBase
// 0x0008 (0x0078 - 0x0070)
class UBTTask_GameplayTaskBase final : public UBTTaskNode
{
public:
	uint8                                         bWaitForGameplayTask : 1;                          // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.BlackboardData
// 0x0020 (0x0050 - 0x0030)
class UBlackboardData final : public UDataAsset
{
public:
	class UBlackboardData*                        Parent;                                            // 0x0030(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FBlackboardEntry>               keys;                                              // 0x0038(0x0010)(Edit, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bHasSynchronizedKeys : 1;                          // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.BTTask_RunBehaviorDynamic
// 0x0018 (0x0088 - 0x0070)
class UBTTask_RunBehaviorDynamic : public UBTTaskNode
{
public:
	struct FGameplayTag                           InjectionTag;                                      // 0x0070(0x0008)(Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UBehaviorTree*                          DefaultBehaviorAsset;                              // 0x0078(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UBehaviorTree*                          BehaviorAsset;                                     // 0x0080(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_RunBehaviorDynamic">();
	}
	static class UBTTask_RunBehaviorDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_RunBehaviorDynamic>();
	}
};
static_assert(alignof(UBTTask_RunBehaviorDynamic) == 0x000008, "Wrong alignment on UBTTask_RunBehaviorDynamic");
static_assert(sizeof(UBTTask_RunBehaviorDynamic) == 0x000088, "Wrong size on UBTTask_RunBehaviorDynamic");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, InjectionTag) == 0x000070, "Member 'UBTTask_RunBehaviorDynamic::InjectionTag' has a wrong offset!");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, DefaultBehaviorAsset) == 0x000078, "Member 'UBTTask_RunBehaviorDynamic::DefaultBehaviorAsset' has a wrong offset!");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, BehaviorAsset) == 0x000080, "Member 'UBTTask_RunBehaviorDynamic::BehaviorAsset' has a wrong offset!");

// Class AIModule.AIBlueprintHelperLibrary
// 0x0000 (0x0028 - 0x0028)
class UAIBlueprintHelperLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class UAIAsyncTaskBlueprintProxy* CreateMoveToProxyObject(class UObject* WorldContextObject, class APawn* Pawn, const struct FVector& Destination, class AActor* TargetActor, float AcceptanceRadius, bool bStopOnOverlap);
	static class AAIController* GetAIController(class AActor* ControlledActor);
	static class UBlackboardComponent* GetBlackboard(class AActor* Target);
	static class UNavigationPath* GetCurrentPath(class AController* Controller);
	static int32 GetCurrentPathIndex(const class AController* Controller);
	static const TArray<struct FVector> GetCurrentPathPoints(class AController* Controller);
	static int32 GetNextNavLinkIndex(const class AController* Controller);
	static bool IsValidAIDirection(const struct FVector& DirectionVector);
	static bool IsValidAILocation(const struct FVector& Location);
	static bool IsValidAIRotation(const struct FRotator& Rotation);
	static void LockAIResourcesWithAnimation(class UAnimInstance* AnimInstance, bool bLockMovement, bool LockAILogic);
	static void SendAIMessage(class APawn* Target, class FName Message, class UObject* MessageSource, bool bSuccess);
	static void SimpleMoveToActor(class AController* Controller, const class AActor* Goal);
	static void SimpleMoveToLocation(class AController* Controller, const struct FVector& Goal);
	static class APawn* SpawnAIFromClass(class UObject* WorldContextObject, TSubclassOf<class APawn> PawnClass, class UBehaviorTree* BehaviorTree, const struct FVector& Location, const struct FRotator& Rotation, bool bNoCollisionFail, class AActor* Owner);
	static void UnlockAIResourcesWithAnimation(class UAnimInstance* AnimInstance, bool bUnlockMovement, bool UnlockAILogic);

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

// Class AIModule.AIDataProvider_Random
// 0x0010 (0x0050 - 0x0040)
class UAIDataProvider_Random final : public UAIDataProvider_QueryParams
{
public:
	float                                         Min;                                               // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Max;                                               // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bInteger : 1;                                      // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIDataProvider_Random">();
	}
	static class UAIDataProvider_Random* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAIDataProvider_Random>();
	}
};
static_assert(alignof(UAIDataProvider_Random) == 0x000008, "Wrong alignment on UAIDataProvider_Random");
static_assert(sizeof(UAIDataProvider_Random) == 0x000050, "Wrong size on UAIDataProvider_Random");
static_assert(offsetof(UAIDataProvider_Random, Min) == 0x000040, "Member 'UAIDataProvider_Random::Min' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_Random, Max) == 0x000044, "Member 'UAIDataProvider_Random::Max' has a wrong offset!");

// Class AIModule.BTTask_MakeNoise
// 0x0008 (0x0078 - 0x0070)
class UBTTask_MakeNoise final : public UBTTaskNode
{
public:
	float                                         Loudnes;                                           // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_74[0x4];                                       // 0x0074(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_MakeNoise">();
	}
	static class UBTTask_MakeNoise* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_MakeNoise>();
	}
};
static_assert(alignof(UBTTask_MakeNoise) == 0x000008, "Wrong alignment on UBTTask_MakeNoise");
static_assert(sizeof(UBTTask_MakeNoise) == 0x000078, "Wrong size on UBTTask_MakeNoise");
static_assert(offsetof(UBTTask_MakeNoise, Loudnes) == 0x000070, "Member 'UBTTask_MakeNoise::Loudnes' has a wrong offset!");

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

// Class AIModule.AIPerceptionComponent
// 0x00E0 (0x0190 - 0x00B0)
class UAIPerceptionComponent final : public UActorComponent
{
public:
	TArray<class UAISenseConfig*>                 SensesConfig;                                      // 0x00B0(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	TSubclassOf<class UAISense>                   DominantSense;                                     // 0x00C0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_C8[0x10];                                      // 0x00C8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class AAIController*                          AIOwner;                                           // 0x00D8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E0[0x80];                                      // 0x00E0(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const TArray<class AActor*>& UpdatedActors)> OnPerceptionUpdated;  // 0x0160(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class AActor* Actor, const struct FAIStimulus& Stimulus)> OnTargetPerceptionUpdated; // 0x0170(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FActorPerceptionUpdateInfo& UpdateInfo)> OnTargetPerceptionInfoUpdated; // 0x0180(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	void ForgetAll();
	bool GetActorsPerception(class AActor* Actor, struct FActorPerceptionBlueprintInfo* Info);
	void OnOwnerEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);
	void RequestStimuliListenerUpdate();
	void SetSenseEnabled(TSubclassOf<class UAISense> SenseClass, const bool bEnable);

	void GetCurrentlyPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
	void GetKnownPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
	void GetPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
	void GetPerceivedHostileActors(TArray<class AActor*>* OutActors) const;
	void GetPerceivedHostileActorsBySense(const TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIPerceptionComponent">();
	}
	static class UAIPerceptionComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAIPerceptionComponent>();
	}
};
static_assert(alignof(UAIPerceptionComponent) == 0x000008, "Wrong alignment on UAIPerceptionComponent");
static_assert(sizeof(UAIPerceptionComponent) == 0x000190, "Wrong size on UAIPerceptionComponent");
static_assert(offsetof(UAIPerceptionComponent, SensesConfig) == 0x0000B0, "Member 'UAIPerceptionComponent::SensesConfig' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, DominantSense) == 0x0000C0, "Member 'UAIPerceptionComponent::DominantSense' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, AIOwner) == 0x0000D8, "Member 'UAIPerceptionComponent::AIOwner' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnPerceptionUpdated) == 0x000160, "Member 'UAIPerceptionComponent::OnPerceptionUpdated' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnTargetPerceptionUpdated) == 0x000170, "Member 'UAIPerceptionComponent::OnTargetPerceptionUpdated' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnTargetPerceptionInfoUpdated) == 0x000180, "Member 'UAIPerceptionComponent::OnTargetPerceptionInfoUpdated' has a wrong offset!");

// Class AIModule.AISubsystem
// 0x0010 (0x0038 - 0x0028)
class UAISubsystem : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UAISystem*                              AISystem;                                          // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

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

// Class AIModule.EnvQueryManager
// 0x0108 (0x0140 - 0x0038)
class UEnvQueryManager final : public UAISubsystem
{
public:
	uint8                                         Pad_38[0x70];                                      // 0x0038(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FEnvQueryInstanceCache>         InstanceCache;                                     // 0x00A8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	TArray<class UEnvQueryContext*>               LocalContexts;                                     // 0x00B8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	TArray<class UEnvQueryInstanceBlueprintWrapper*> GCShieldedWrappers;                             // 0x00C8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_D8[0x54];                                      // 0x00D8(0x0054)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxAllowedTestingTime;                             // 0x012C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bTestQueriesUsingBreadth;                          // 0x0130(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_131[0x3];                                      // 0x0131(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         QueryCountWarningThreshold;                        // 0x0134(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	double                                        QueryCountWarningInterval;                         // 0x0138(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UEnvQueryInstanceBlueprintWrapper* RunEQSQuery(class UObject* WorldContextObject, class UEnvQuery* QueryTemplate, class UObject* Querier, EEnvQueryRunMode RunMode, TSubclassOf<class UEnvQueryInstanceBlueprintWrapper> WrapperClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryManager">();
	}
	static class UEnvQueryManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryManager>();
	}
};
static_assert(alignof(UEnvQueryManager) == 0x000008, "Wrong alignment on UEnvQueryManager");
static_assert(sizeof(UEnvQueryManager) == 0x000140, "Wrong size on UEnvQueryManager");
static_assert(offsetof(UEnvQueryManager, InstanceCache) == 0x0000A8, "Member 'UEnvQueryManager::InstanceCache' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, LocalContexts) == 0x0000B8, "Member 'UEnvQueryManager::LocalContexts' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, GCShieldedWrappers) == 0x0000C8, "Member 'UEnvQueryManager::GCShieldedWrappers' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, MaxAllowedTestingTime) == 0x00012C, "Member 'UEnvQueryManager::MaxAllowedTestingTime' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, bTestQueriesUsingBreadth) == 0x000130, "Member 'UEnvQueryManager::bTestQueriesUsingBreadth' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, QueryCountWarningThreshold) == 0x000134, "Member 'UEnvQueryManager::QueryCountWarningThreshold' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, QueryCountWarningInterval) == 0x000138, "Member 'UEnvQueryManager::QueryCountWarningInterval' has a wrong offset!");

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

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

// Class AIModule.AIPerceptionStimuliSourceComponent
// 0x0018 (0x00C8 - 0x00B0)
class UAIPerceptionStimuliSourceComponent final : public UActorComponent
{
public:
	uint8                                         bAutoRegisterAsSource : 1;                         // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TSubclassOf<class UAISense>>           RegisterAsSourceForSenses;                         // 0x00B8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	void RegisterForSense(TSubclassOf<class UAISense> SenseClass);
	void RegisterWithPerceptionSystem();
	void UnregisterFromPerceptionSystem();
	void UnregisterFromSense(TSubclassOf<class UAISense> SenseClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIPerceptionStimuliSourceComponent">();
	}
	static class UAIPerceptionStimuliSourceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAIPerceptionStimuliSourceComponent>();
	}
};
static_assert(alignof(UAIPerceptionStimuliSourceComponent) == 0x000008, "Wrong alignment on UAIPerceptionStimuliSourceComponent");
static_assert(sizeof(UAIPerceptionStimuliSourceComponent) == 0x0000C8, "Wrong size on UAIPerceptionStimuliSourceComponent");
static_assert(offsetof(UAIPerceptionStimuliSourceComponent, RegisterAsSourceForSenses) == 0x0000B8, "Member 'UAIPerceptionStimuliSourceComponent::RegisterAsSourceForSenses' has a wrong offset!");

// Class AIModule.AIPerceptionSystem
// 0x00F8 (0x0130 - 0x0038)
class UAIPerceptionSystem final : public UAISubsystem
{
public:
	uint8                                         Pad_38[0x50];                                      // 0x0038(0x0050)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAISense*>                       Senses;                                            // 0x0088(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	float                                         PerceptionAgingRate;                               // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_9C[0x94];                                      // 0x009C(0x0094)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static TSubclassOf<class UAISense> GetSenseClassForStimulus(class UObject* WorldContextObject, const struct FAIStimulus& Stimulus);
	static bool RegisterPerceptionStimuliSource(class UObject* WorldContextObject, TSubclassOf<class UAISense> Sense, class AActor* Target);
	static void ReportPerceptionEvent(class UObject* WorldContextObject, class UAISenseEvent* PerceptionEvent);

	void OnPerceptionStimuliSourceEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);
	void ReportEvent(class UAISenseEvent* PerceptionEvent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AIPerceptionSystem">();
	}
	static class UAIPerceptionSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAIPerceptionSystem>();
	}
};
static_assert(alignof(UAIPerceptionSystem) == 0x000008, "Wrong alignment on UAIPerceptionSystem");
static_assert(sizeof(UAIPerceptionSystem) == 0x000130, "Wrong size on UAIPerceptionSystem");
static_assert(offsetof(UAIPerceptionSystem, Senses) == 0x000088, "Member 'UAIPerceptionSystem::Senses' has a wrong offset!");
static_assert(offsetof(UAIPerceptionSystem, PerceptionAgingRate) == 0x000098, "Member 'UAIPerceptionSystem::PerceptionAgingRate' has a wrong offset!");

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

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

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

// Class AIModule.BTTask_RunBehavior
// 0x0008 (0x0078 - 0x0070)
class UBTTask_RunBehavior final : public UBTTaskNode
{
public:
	class UBehaviorTree*                          BehaviorAsset;                                     // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_RunBehavior">();
	}
	static class UBTTask_RunBehavior* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_RunBehavior>();
	}
};
static_assert(alignof(UBTTask_RunBehavior) == 0x000008, "Wrong alignment on UBTTask_RunBehavior");
static_assert(sizeof(UBTTask_RunBehavior) == 0x000078, "Wrong size on UBTTask_RunBehavior");
static_assert(offsetof(UBTTask_RunBehavior, BehaviorAsset) == 0x000070, "Member 'UBTTask_RunBehavior::BehaviorAsset' has a wrong offset!");

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

// Class AIModule.EnvQueryTest_Project
// 0x0030 (0x0228 - 0x01F8)
class UEnvQueryTest_Project final : public UEnvQueryTest
{
public:
	struct FEnvTraceData                          ProjectionData;                                    // 0x01F8(0x0030)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)

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

// Class AIModule.AISense_Blueprint
// 0x0028 (0x00A8 - 0x0080)
class UAISense_Blueprint final : public UAISense
{
public:
	TSubclassOf<class UUserDefinedStruct>         ListenerDataType;                                  // 0x0080(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UAIPerceptionComponent*>         ListenerContainer;                                 // 0x0088(0x0010)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	TArray<class UAISenseEvent*>                  UnprocessedEvents;                                 // 0x0098(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	void K2_OnNewPawn(class APawn* NewPawn);
	void OnListenerRegistered(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
	void OnListenerUnregistered(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
	void OnListenerUpdated(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
	float OnUpdate(const TArray<class UAISenseEvent*>& EventsToProcess);

	void GetAllListenerActors(TArray<class AActor*>* ListenerActors) const;
	void GetAllListenerComponents(TArray<class UAIPerceptionComponent*>* ListenerComponents) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISense_Blueprint">();
	}
	static class UAISense_Blueprint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISense_Blueprint>();
	}
};
static_assert(alignof(UAISense_Blueprint) == 0x000008, "Wrong alignment on UAISense_Blueprint");
static_assert(sizeof(UAISense_Blueprint) == 0x0000A8, "Wrong size on UAISense_Blueprint");
static_assert(offsetof(UAISense_Blueprint, ListenerDataType) == 0x000080, "Member 'UAISense_Blueprint::ListenerDataType' has a wrong offset!");
static_assert(offsetof(UAISense_Blueprint, ListenerContainer) == 0x000088, "Member 'UAISense_Blueprint::ListenerContainer' has a wrong offset!");
static_assert(offsetof(UAISense_Blueprint, UnprocessedEvents) == 0x000098, "Member 'UAISense_Blueprint::UnprocessedEvents' has a wrong offset!");

// Class AIModule.AISense_Damage
// 0x0010 (0x0090 - 0x0080)
class UAISense_Damage final : public UAISense
{
public:
	TArray<struct FAIDamageEvent>                 RegisteredEvents;                                  // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static void ReportDamageEvent(class UObject* WorldContextObject, class AActor* DamagedActor, class AActor* Instigator, float DamageAmount, const struct FVector& EventLocation, const struct FVector& HitLocation, class FName Tag);

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

// Class AIModule.EnvQueryItemType
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryItemType : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

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

// Class AIModule.AISense_Hearing
// 0x0068 (0x00E8 - 0x0080)
class UAISense_Hearing final : public UAISense
{
public:
	TArray<struct FAINoiseEvent>                  NoiseEvents;                                       // 0x0080(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	float                                         SpeedOfSoundSq;                                    // 0x0090(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_94[0x54];                                      // 0x0094(0x0054)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static void ReportNoiseEvent(class UObject* WorldContextObject, const struct FVector& NoiseLocation, float Loudness, class AActor* Instigator, float MaxRange, class FName Tag);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISense_Hearing">();
	}
	static class UAISense_Hearing* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISense_Hearing>();
	}
};
static_assert(alignof(UAISense_Hearing) == 0x000008, "Wrong alignment on UAISense_Hearing");
static_assert(sizeof(UAISense_Hearing) == 0x0000E8, "Wrong size on UAISense_Hearing");
static_assert(offsetof(UAISense_Hearing, NoiseEvents) == 0x000080, "Member 'UAISense_Hearing::NoiseEvents' has a wrong offset!");
static_assert(offsetof(UAISense_Hearing, SpeedOfSoundSq) == 0x000090, "Member 'UAISense_Hearing::SpeedOfSoundSq' has a wrong offset!");

// Class AIModule.AISense_Prediction
// 0x0010 (0x0090 - 0x0080)
class UAISense_Prediction final : public UAISense
{
public:
	TArray<struct FAIPredictionEvent>             RegisteredEvents;                                  // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static void RequestControllerPredictionEvent(class AAIController* Requestor, class AActor* PredictedActor, float PredictionTime);
	static void RequestPawnPredictionEvent(class APawn* Requestor, class AActor* PredictedActor, float PredictionTime);

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

// Class AIModule.AISense_Sight
// 0x00F0 (0x0170 - 0x0080)
class UAISense_Sight final : public UAISense
{
public:
	uint8                                         Pad_80[0xC8];                                      // 0x0080(0x00C8)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaxTracesPerTick;                                  // 0x0148(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MinQueriesPerTimeSliceCheck;                       // 0x014C(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	double                                        MaxTimeSlicePerTick;                               // 0x0150(0x0008)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         HighImportanceQueryDistanceThreshold;              // 0x0158(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_15C[0x4];                                      // 0x015C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxQueryImportance;                                // 0x0160(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         SightLimitQueryImportance;                         // 0x0164(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_168[0x8];                                      // 0x0168(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISense_Sight">();
	}
	static class UAISense_Sight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISense_Sight>();
	}
};
static_assert(alignof(UAISense_Sight) == 0x000008, "Wrong alignment on UAISense_Sight");
static_assert(sizeof(UAISense_Sight) == 0x000170, "Wrong size on UAISense_Sight");
static_assert(offsetof(UAISense_Sight, MaxTracesPerTick) == 0x000148, "Member 'UAISense_Sight::MaxTracesPerTick' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MinQueriesPerTimeSliceCheck) == 0x00014C, "Member 'UAISense_Sight::MinQueriesPerTimeSliceCheck' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MaxTimeSlicePerTick) == 0x000150, "Member 'UAISense_Sight::MaxTimeSlicePerTick' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, HighImportanceQueryDistanceThreshold) == 0x000158, "Member 'UAISense_Sight::HighImportanceQueryDistanceThreshold' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MaxQueryImportance) == 0x000160, "Member 'UAISense_Sight::MaxQueryImportance' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, SightLimitQueryImportance) == 0x000164, "Member 'UAISense_Sight::SightLimitQueryImportance' has a wrong offset!");

// Class AIModule.AISense_Touch
// 0x0010 (0x0090 - 0x0080)
class UAISense_Touch final : public UAISense
{
public:
	TArray<struct FAITouchEvent>                  RegisteredEvents;                                  // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

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

// Class AIModule.AISenseBlueprintListener
// 0x0000 (0x0108 - 0x0108)
class UAISenseBlueprintListener final : public UUserDefinedStruct
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISenseBlueprintListener">();
	}
	static class UAISenseBlueprintListener* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISenseBlueprintListener>();
	}
};
static_assert(alignof(UAISenseBlueprintListener) == 0x000008, "Wrong alignment on UAISenseBlueprintListener");
static_assert(sizeof(UAISenseBlueprintListener) == 0x000108, "Wrong size on UAISenseBlueprintListener");

// Class AIModule.AISenseConfig_Blueprint
// 0x0008 (0x0050 - 0x0048)
class UAISenseConfig_Blueprint final : public UAISenseConfig
{
public:
	TSubclassOf<class UAISense_Blueprint>         Implementation;                                    // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class AIModule.AISenseConfig_Hearing
// 0x0018 (0x0060 - 0x0048)
class UAISenseConfig_Hearing final : public UAISenseConfig
{
public:
	TSubclassOf<class UAISense_Hearing>           Implementation;                                    // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HearingRange;                                      // 0x0050(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LoSHearingRange;                                   // 0x0054(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseLoSHearing : 1;                                // 0x0058(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_59[0x3];                                       // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAISenseAffiliationFilter              DetectionByAffiliation;                            // 0x005C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISenseConfig_Hearing">();
	}
	static class UAISenseConfig_Hearing* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISenseConfig_Hearing>();
	}
};
static_assert(alignof(UAISenseConfig_Hearing) == 0x000008, "Wrong alignment on UAISenseConfig_Hearing");
static_assert(sizeof(UAISenseConfig_Hearing) == 0x000060, "Wrong size on UAISenseConfig_Hearing");
static_assert(offsetof(UAISenseConfig_Hearing, Implementation) == 0x000048, "Member 'UAISenseConfig_Hearing::Implementation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, HearingRange) == 0x000050, "Member 'UAISenseConfig_Hearing::HearingRange' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, LoSHearingRange) == 0x000054, "Member 'UAISenseConfig_Hearing::LoSHearingRange' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, DetectionByAffiliation) == 0x00005C, "Member 'UAISenseConfig_Hearing::DetectionByAffiliation' has a wrong offset!");

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

// Class AIModule.AISenseConfig_Sight
// 0x0028 (0x0070 - 0x0048)
class UAISenseConfig_Sight final : public UAISenseConfig
{
public:
	TSubclassOf<class UAISense_Sight>             Implementation;                                    // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SightRadius;                                       // 0x0050(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LoseSightRadius;                                   // 0x0054(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PeripheralVisionAngleDegrees;                      // 0x0058(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAISenseAffiliationFilter              DetectionByAffiliation;                            // 0x005C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	float                                         AutoSuccessRangeFromLastSeenLocation;              // 0x0060(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PointOfViewBackwardOffset;                         // 0x0064(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NearClippingRadius;                                // 0x0068(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISenseConfig_Sight">();
	}
	static class UAISenseConfig_Sight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISenseConfig_Sight>();
	}
};
static_assert(alignof(UAISenseConfig_Sight) == 0x000008, "Wrong alignment on UAISenseConfig_Sight");
static_assert(sizeof(UAISenseConfig_Sight) == 0x000070, "Wrong size on UAISenseConfig_Sight");
static_assert(offsetof(UAISenseConfig_Sight, Implementation) == 0x000048, "Member 'UAISenseConfig_Sight::Implementation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, SightRadius) == 0x000050, "Member 'UAISenseConfig_Sight::SightRadius' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, LoseSightRadius) == 0x000054, "Member 'UAISenseConfig_Sight::LoseSightRadius' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, PeripheralVisionAngleDegrees) == 0x000058, "Member 'UAISenseConfig_Sight::PeripheralVisionAngleDegrees' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, DetectionByAffiliation) == 0x00005C, "Member 'UAISenseConfig_Sight::DetectionByAffiliation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, AutoSuccessRangeFromLastSeenLocation) == 0x000060, "Member 'UAISenseConfig_Sight::AutoSuccessRangeFromLastSeenLocation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, PointOfViewBackwardOffset) == 0x000064, "Member 'UAISenseConfig_Sight::PointOfViewBackwardOffset' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, NearClippingRadius) == 0x000068, "Member 'UAISenseConfig_Sight::NearClippingRadius' has a wrong offset!");

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

// Class AIModule.PawnAction
// 0x0068 (0x0090 - 0x0028)
class UPawnAction : public UObject
{
public:
	class UPawnAction*                            ChildAction;                                       // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UPawnAction*                            ParentAction;                                      // 0x0030(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UPawnActionsComponent*                  OwnerComponent;                                    // 0x0038(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UObject*                                Instigator;                                        // 0x0040(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBrainComponent*                        BrainComp;                                         // 0x0048(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_50[0x30];                                      // 0x0050(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bAllowNewSameClassInstance : 1;                    // 0x0080(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bReplaceActiveSameClassInstance : 1;               // 0x0080(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bShouldPauseMovement : 1;                          // 0x0080(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAlwaysNotifyOnFinished : 1;                       // 0x0080(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_81[0xF];                                       // 0x0081(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UPawnAction* CreateActionInstance(class UObject* WorldContextObject, TSubclassOf<class UPawnAction> ActionClass);

	void Finish(EPawnActionResult WithResult);
	EAIRequestPriority GetActionPriority();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnAction">();
	}
	static class UPawnAction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnAction>();
	}
};
static_assert(alignof(UPawnAction) == 0x000008, "Wrong alignment on UPawnAction");
static_assert(sizeof(UPawnAction) == 0x000090, "Wrong size on UPawnAction");
static_assert(offsetof(UPawnAction, ChildAction) == 0x000028, "Member 'UPawnAction::ChildAction' has a wrong offset!");
static_assert(offsetof(UPawnAction, ParentAction) == 0x000030, "Member 'UPawnAction::ParentAction' has a wrong offset!");
static_assert(offsetof(UPawnAction, OwnerComponent) == 0x000038, "Member 'UPawnAction::OwnerComponent' has a wrong offset!");
static_assert(offsetof(UPawnAction, Instigator) == 0x000040, "Member 'UPawnAction::Instigator' has a wrong offset!");
static_assert(offsetof(UPawnAction, BrainComp) == 0x000048, "Member 'UPawnAction::BrainComp' has a wrong offset!");

// Class AIModule.PawnAction_BlueprintBase
// 0x0000 (0x0090 - 0x0090)
class UPawnAction_BlueprintBase final : public UPawnAction
{
public:
	void ActionFinished(class APawn* ControlledPawn, EPawnActionResult WithResult);
	void ActionPause(class APawn* ControlledPawn);
	void ActionResume(class APawn* ControlledPawn);
	void ActionStart(class APawn* ControlledPawn);
	void ActionTick(class APawn* ControlledPawn, float DeltaSeconds);

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

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

// Class AIModule.AISenseEvent_Damage
// 0x0038 (0x0060 - 0x0028)
class UAISenseEvent_Damage final : public UAISenseEvent
{
public:
	struct FAIDamageEvent                         Event;                                             // 0x0028(0x0038)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)

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

// Class AIModule.AISenseEvent_Hearing
// 0x0030 (0x0058 - 0x0028)
class UAISenseEvent_Hearing final : public UAISenseEvent
{
public:
	struct FAINoiseEvent                          Event;                                             // 0x0028(0x0030)(Edit, BlueprintVisible, NoDestructor, Protected, NativeAccessSpecifierProtected)

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

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

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

// Class AIModule.AITask_LockLogic
// 0x0000 (0x0070 - 0x0070)
class UAITask_LockLogic final : public UAITask
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AITask_LockLogic">();
	}
	static class UAITask_LockLogic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAITask_LockLogic>();
	}
};
static_assert(alignof(UAITask_LockLogic) == 0x000008, "Wrong alignment on UAITask_LockLogic");
static_assert(sizeof(UAITask_LockLogic) == 0x000070, "Wrong size on UAITask_LockLogic");

// Class AIModule.AITask_MoveTo
// 0x00A0 (0x0110 - 0x0070)
class UAITask_MoveTo final : public UAITask
{
public:
	TMulticastInlineDelegate<void()>              OnRequestFailed;                                   // 0x0070(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
	TMulticastInlineDelegate<void(EPathFollowingResult Result, class AAIController* AIController)> OnMoveFinished; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
	struct FAIMoveRequest                         MoveRequest;                                       // 0x0090(0x0040)(Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_D0[0x40];                                      // 0x00D0(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAITask_MoveTo* AIMoveTo(class AAIController* Controller, const struct FVector& GoalLocation, class AActor* GoalActor, float AcceptanceRadius, EAIOptionFlag StopOnOverlap, EAIOptionFlag AcceptPartialPath, bool bUsePathfinding, bool bLockAILogic, bool bUseContinuosGoalTracking, EAIOptionFlag ProjectGoalOnNavigation);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AITask_MoveTo">();
	}
	static class UAITask_MoveTo* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAITask_MoveTo>();
	}
};
static_assert(alignof(UAITask_MoveTo) == 0x000008, "Wrong alignment on UAITask_MoveTo");
static_assert(sizeof(UAITask_MoveTo) == 0x000110, "Wrong size on UAITask_MoveTo");
static_assert(offsetof(UAITask_MoveTo, OnRequestFailed) == 0x000070, "Member 'UAITask_MoveTo::OnRequestFailed' has a wrong offset!");
static_assert(offsetof(UAITask_MoveTo, OnMoveFinished) == 0x000080, "Member 'UAITask_MoveTo::OnMoveFinished' has a wrong offset!");
static_assert(offsetof(UAITask_MoveTo, MoveRequest) == 0x000090, "Member 'UAITask_MoveTo::MoveRequest' has a wrong offset!");

// Class AIModule.BehaviorTree
// 0x0040 (0x0068 - 0x0028)
class UBehaviorTree final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UBTCompositeNode*                       RootNode;                                          // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBlackboardData*                        BlackboardAsset;                                   // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UBTDecorator*>                   RootDecorators;                                    // 0x0040(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FBTDecoratorLogic>              RootDecoratorOps;                                  // 0x0050(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x8];                                       // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BehaviorTree">();
	}
	static class UBehaviorTree* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBehaviorTree>();
	}
};
static_assert(alignof(UBehaviorTree) == 0x000008, "Wrong alignment on UBehaviorTree");
static_assert(sizeof(UBehaviorTree) == 0x000068, "Wrong size on UBehaviorTree");
static_assert(offsetof(UBehaviorTree, RootNode) == 0x000030, "Member 'UBehaviorTree::RootNode' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, BlackboardAsset) == 0x000038, "Member 'UBehaviorTree::BlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, RootDecorators) == 0x000040, "Member 'UBehaviorTree::RootDecorators' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, RootDecoratorOps) == 0x000050, "Member 'UBehaviorTree::RootDecoratorOps' has a wrong offset!");

// Class AIModule.BehaviorTreeManager
// 0x0028 (0x0050 - 0x0028)
class UBehaviorTreeManager final : public UObject
{
public:
	int32                                         MaxDebuggerSteps;                                  // 0x0028(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBehaviorTreeTemplateInfo>      LoadedTemplates;                                   // 0x0030(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<class UBehaviorTreeComponent*>         ActiveComponents;                                  // 0x0040(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BehaviorTreeManager">();
	}
	static class UBehaviorTreeManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBehaviorTreeManager>();
	}
};
static_assert(alignof(UBehaviorTreeManager) == 0x000008, "Wrong alignment on UBehaviorTreeManager");
static_assert(sizeof(UBehaviorTreeManager) == 0x000050, "Wrong size on UBehaviorTreeManager");
static_assert(offsetof(UBehaviorTreeManager, MaxDebuggerSteps) == 0x000028, "Member 'UBehaviorTreeManager::MaxDebuggerSteps' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeManager, LoadedTemplates) == 0x000030, "Member 'UBehaviorTreeManager::LoadedTemplates' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeManager, ActiveComponents) == 0x000040, "Member 'UBehaviorTreeManager::ActiveComponents' has a wrong offset!");

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

// Class AIModule.BlackboardComponent
// 0x0108 (0x01B8 - 0x00B0)
class UBlackboardComponent final : public UActorComponent
{
public:
	class UBrainComponent*                        BrainComp;                                         // 0x00B0(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UBlackboardData*                        DefaultBlackboardAsset;                            // 0x00B8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UBlackboardData*                        BlackboardAsset;                                   // 0x00C0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_C8[0x20];                                      // 0x00C8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UBlackboardKeyType*>             KeyInstances;                                      // 0x00E8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_F8[0xC0];                                      // 0x00F8(0x00C0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearValue(const class FName& KeyName);
	void SetValueAsBool(const class FName& KeyName, bool BoolValue);
	void SetValueAsClass(const class FName& KeyName, class UClass* ClassValue);
	void SetValueAsEnum(const class FName& KeyName, uint8 EnumValue);
	void SetValueAsFloat(const class FName& KeyName, float FloatValue);
	void SetValueAsInt(const class FName& KeyName, int32 IntValue);
	void SetValueAsName(const class FName& KeyName, class FName NameValue);
	void SetValueAsObject(const class FName& KeyName, class UObject* ObjectValue);
	void SetValueAsRotator(const class FName& KeyName, const struct FRotator& VectorValue);
	void SetValueAsString(const class FName& KeyName, const class FString& StringValue);
	void SetValueAsVector(const class FName& KeyName, const struct FVector& VectorValue);

	bool GetLocationFromEntry(const class FName& KeyName, struct FVector* ResultLocation) const;
	bool GetRotationFromEntry(const class FName& KeyName, struct FRotator* ResultRotation) const;
	bool GetValueAsBool(const class FName& KeyName) const;
	class UClass* GetValueAsClass(const class FName& KeyName) const;
	uint8 GetValueAsEnum(const class FName& KeyName) const;
	float GetValueAsFloat(const class FName& KeyName) const;
	int32 GetValueAsInt(const class FName& KeyName) const;
	class FName GetValueAsName(const class FName& KeyName) const;
	class UObject* GetValueAsObject(const class FName& KeyName) const;
	struct FRotator GetValueAsRotator(const class FName& KeyName) const;
	class FString GetValueAsString(const class FName& KeyName) const;
	struct FVector GetValueAsVector(const class FName& KeyName) const;
	bool IsVectorValueSet(const class FName& KeyName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlackboardComponent">();
	}
	static class UBlackboardComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlackboardComponent>();
	}
};
static_assert(alignof(UBlackboardComponent) == 0x000008, "Wrong alignment on UBlackboardComponent");
static_assert(sizeof(UBlackboardComponent) == 0x0001B8, "Wrong size on UBlackboardComponent");
static_assert(offsetof(UBlackboardComponent, BrainComp) == 0x0000B0, "Member 'UBlackboardComponent::BrainComp' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, DefaultBlackboardAsset) == 0x0000B8, "Member 'UBlackboardComponent::DefaultBlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, BlackboardAsset) == 0x0000C0, "Member 'UBlackboardComponent::BlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, KeyInstances) == 0x0000E8, "Member 'UBlackboardComponent::KeyInstances' has a wrong offset!");

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

// Class AIModule.BlackboardKeyType_Class
// 0x0008 (0x0038 - 0x0030)
class UBlackboardKeyType_Class final : public UBlackboardKeyType
{
public:
	class UClass*                                 BaseClass;                                         // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class AIModule.BlackboardKeyType_Enum
// 0x0020 (0x0050 - 0x0030)
class UBlackboardKeyType_Enum final : public UBlackboardKeyType
{
public:
	class UEnum*                                  EnumType;                                          // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 EnumName;                                          // 0x0038(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsEnumNameValid : 1;                              // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.PawnSensingComponent
// 0x0048 (0x00F8 - 0x00B0)
class UPawnSensingComponent final : public UActorComponent
{
public:
	float                                         HearingThreshold;                                  // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LOSHearingThreshold;                               // 0x00B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SightRadius;                                       // 0x00B8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SensingInterval;                                   // 0x00BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HearingMaxSoundAge;                                // 0x00C0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableSensingUpdates : 1;                         // 0x00C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOnlySensePlayers : 1;                             // 0x00C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSeePawns : 1;                                     // 0x00C4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHearNoises : 1;                                   // 0x00C4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C5[0xB];                                       // 0x00C5(0x000B)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class APawn* Pawn)> OnSeePawn;                                     // 0x00D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class APawn* Instigator, const struct FVector& Location, float Volume)> OnHearNoise; // 0x00E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	float                                         PeripheralVisionAngle;                             // 0x00F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         PeripheralVisionCosine;                            // 0x00F4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void SetPeripheralVisionAngle(const float NewPeripheralVisionAngle);
	void SetSensingInterval(const float NewSensingInterval);
	void SetSensingUpdatesEnabled(const bool bEnabled);

	float GetPeripheralVisionAngle() const;
	float GetPeripheralVisionCosine() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnSensingComponent">();
	}
	static class UPawnSensingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnSensingComponent>();
	}
};
static_assert(alignof(UPawnSensingComponent) == 0x000008, "Wrong alignment on UPawnSensingComponent");
static_assert(sizeof(UPawnSensingComponent) == 0x0000F8, "Wrong size on UPawnSensingComponent");
static_assert(offsetof(UPawnSensingComponent, HearingThreshold) == 0x0000B0, "Member 'UPawnSensingComponent::HearingThreshold' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, LOSHearingThreshold) == 0x0000B4, "Member 'UPawnSensingComponent::LOSHearingThreshold' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, SightRadius) == 0x0000B8, "Member 'UPawnSensingComponent::SightRadius' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, SensingInterval) == 0x0000BC, "Member 'UPawnSensingComponent::SensingInterval' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, HearingMaxSoundAge) == 0x0000C0, "Member 'UPawnSensingComponent::HearingMaxSoundAge' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, OnSeePawn) == 0x0000D0, "Member 'UPawnSensingComponent::OnSeePawn' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, OnHearNoise) == 0x0000E0, "Member 'UPawnSensingComponent::OnHearNoise' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, PeripheralVisionAngle) == 0x0000F0, "Member 'UPawnSensingComponent::PeripheralVisionAngle' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, PeripheralVisionCosine) == 0x0000F4, "Member 'UPawnSensingComponent::PeripheralVisionCosine' has a wrong offset!");

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

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

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

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

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

// Class AIModule.BlackboardKeyType_String
// 0x0010 (0x0040 - 0x0030)
class UBlackboardKeyType_String final : public UBlackboardKeyType
{
public:
	class FString                                 StringValue;                                       // 0x0030(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

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

// Class AIModule.BTComposite_Selector
// 0x0000 (0x0090 - 0x0090)
class UBTComposite_Selector final : public UBTCompositeNode
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTComposite_Selector">();
	}
	static class UBTComposite_Selector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTComposite_Selector>();
	}
};
static_assert(alignof(UBTComposite_Selector) == 0x000008, "Wrong alignment on UBTComposite_Selector");
static_assert(sizeof(UBTComposite_Selector) == 0x000090, "Wrong size on UBTComposite_Selector");

// Class AIModule.BTComposite_Sequence
// 0x0000 (0x0090 - 0x0090)
class UBTComposite_Sequence final : public UBTCompositeNode
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTComposite_Sequence">();
	}
	static class UBTComposite_Sequence* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTComposite_Sequence>();
	}
};
static_assert(alignof(UBTComposite_Sequence) == 0x000008, "Wrong alignment on UBTComposite_Sequence");
static_assert(sizeof(UBTComposite_Sequence) == 0x000090, "Wrong size on UBTComposite_Sequence");

// Class AIModule.BTComposite_SimpleParallel
// 0x0008 (0x0098 - 0x0090)
class UBTComposite_SimpleParallel final : public UBTCompositeNode
{
public:
	EBTParallelMode                               FinishMode;                                        // 0x0090(0x0001)(Edit, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTComposite_SimpleParallel">();
	}
	static class UBTComposite_SimpleParallel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTComposite_SimpleParallel>();
	}
};
static_assert(alignof(UBTComposite_SimpleParallel) == 0x000008, "Wrong alignment on UBTComposite_SimpleParallel");
static_assert(sizeof(UBTComposite_SimpleParallel) == 0x000098, "Wrong size on UBTComposite_SimpleParallel");
static_assert(offsetof(UBTComposite_SimpleParallel, FinishMode) == 0x000090, "Member 'UBTComposite_SimpleParallel::FinishMode' has a wrong offset!");

// Class AIModule.BTDecorator_Blackboard
// 0x0030 (0x00C0 - 0x0090)
class UBTDecorator_Blackboard : public UBTDecorator_BlackboardBase
{
public:
	int32                                         IntValue;                                          // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         FloatValue;                                        // 0x0094(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FString                                 StringValue;                                       // 0x0098(0x0010)(Edit, ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FString                                 CachedDescription;                                 // 0x00A8(0x0010)(ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         OperationType;                                     // 0x00B8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EBTBlackboardRestart                          NotifyObserver;                                    // 0x00B9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_BA[0x6];                                       // 0x00BA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_Blackboard">();
	}
	static class UBTDecorator_Blackboard* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_Blackboard>();
	}
};
static_assert(alignof(UBTDecorator_Blackboard) == 0x000008, "Wrong alignment on UBTDecorator_Blackboard");
static_assert(sizeof(UBTDecorator_Blackboard) == 0x0000C0, "Wrong size on UBTDecorator_Blackboard");
static_assert(offsetof(UBTDecorator_Blackboard, IntValue) == 0x000090, "Member 'UBTDecorator_Blackboard::IntValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, FloatValue) == 0x000094, "Member 'UBTDecorator_Blackboard::FloatValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, StringValue) == 0x000098, "Member 'UBTDecorator_Blackboard::StringValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, CachedDescription) == 0x0000A8, "Member 'UBTDecorator_Blackboard::CachedDescription' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, OperationType) == 0x0000B8, "Member 'UBTDecorator_Blackboard::OperationType' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, NotifyObserver) == 0x0000B9, "Member 'UBTDecorator_Blackboard::NotifyObserver' has a wrong offset!");

// Class AIModule.BTDecorator_BlueprintBase
// 0x0038 (0x00A0 - 0x0068)
class UBTDecorator_BlueprintBase final : public UBTDecorator
{
public:
	class AAIController*                          AIOwner;                                           // 0x0068(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 ActorOwner;                                        // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class FName>                           ObservedKeyNames;                                  // 0x0078(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_88[0x10];                                      // 0x0088(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bShowPropertyDetails : 1;                          // 0x0098(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCheckConditionOnlyBlackBoardChanges : 1;          // 0x0098(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bIsObservingBB : 1;                                // 0x0098(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool PerformConditionCheck(class AActor* OwnerActor);
	bool PerformConditionCheckAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveExecutionFinish(class AActor* OwnerActor, EBTNodeResult NodeResult);
	void ReceiveExecutionFinishAI(class AAIController* OwnerController, class APawn* ControlledPawn, EBTNodeResult NodeResult);
	void ReceiveExecutionStart(class AActor* OwnerActor);
	void ReceiveExecutionStartAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveObserverActivated(class AActor* OwnerActor);
	void ReceiveObserverActivatedAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveObserverDeactivated(class AActor* OwnerActor);
	void ReceiveObserverDeactivatedAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
	void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);

	bool IsDecoratorExecutionActive() const;
	bool IsDecoratorObserverActive() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_BlueprintBase">();
	}
	static class UBTDecorator_BlueprintBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_BlueprintBase>();
	}
};
static_assert(alignof(UBTDecorator_BlueprintBase) == 0x000008, "Wrong alignment on UBTDecorator_BlueprintBase");
static_assert(sizeof(UBTDecorator_BlueprintBase) == 0x0000A0, "Wrong size on UBTDecorator_BlueprintBase");
static_assert(offsetof(UBTDecorator_BlueprintBase, AIOwner) == 0x000068, "Member 'UBTDecorator_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTDecorator_BlueprintBase, ActorOwner) == 0x000070, "Member 'UBTDecorator_BlueprintBase::ActorOwner' has a wrong offset!");
static_assert(offsetof(UBTDecorator_BlueprintBase, ObservedKeyNames) == 0x000078, "Member 'UBTDecorator_BlueprintBase::ObservedKeyNames' has a wrong offset!");

// Class AIModule.BTDecorator_CheckGameplayTagsOnActor
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_CheckGameplayTagsOnActor final : public UBTDecorator
{
public:
	struct FBlackboardKeySelector                 ActorToCheck;                                      // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
	EGameplayContainerMatchType                   TagsToMatch;                                       // 0x0090(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  GameplayTags;                                      // 0x0098(0x0020)(Edit, Protected, NativeAccessSpecifierProtected)
	class FString                                 CachedDescription;                                 // 0x00B8(0x0010)(ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_CheckGameplayTagsOnActor">();
	}
	static class UBTDecorator_CheckGameplayTagsOnActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_CheckGameplayTagsOnActor>();
	}
};
static_assert(alignof(UBTDecorator_CheckGameplayTagsOnActor) == 0x000008, "Wrong alignment on UBTDecorator_CheckGameplayTagsOnActor");
static_assert(sizeof(UBTDecorator_CheckGameplayTagsOnActor) == 0x0000C8, "Wrong size on UBTDecorator_CheckGameplayTagsOnActor");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, ActorToCheck) == 0x000068, "Member 'UBTDecorator_CheckGameplayTagsOnActor::ActorToCheck' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, TagsToMatch) == 0x000090, "Member 'UBTDecorator_CheckGameplayTagsOnActor::TagsToMatch' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, GameplayTags) == 0x000098, "Member 'UBTDecorator_CheckGameplayTagsOnActor::GameplayTags' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, CachedDescription) == 0x0000B8, "Member 'UBTDecorator_CheckGameplayTagsOnActor::CachedDescription' has a wrong offset!");

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

// Class AIModule.BTDecorator_ConditionalLoop
// 0x0000 (0x00C0 - 0x00C0)
class UBTDecorator_ConditionalLoop final : public UBTDecorator_Blackboard
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_ConditionalLoop">();
	}
	static class UBTDecorator_ConditionalLoop* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_ConditionalLoop>();
	}
};
static_assert(alignof(UBTDecorator_ConditionalLoop) == 0x000008, "Wrong alignment on UBTDecorator_ConditionalLoop");
static_assert(sizeof(UBTDecorator_ConditionalLoop) == 0x0000C0, "Wrong size on UBTDecorator_ConditionalLoop");

// Class AIModule.BTDecorator_ConeCheck
// 0x0088 (0x00F0 - 0x0068)
class UBTDecorator_ConeCheck final : public UBTDecorator
{
public:
	float                                         ConeHalfAngle;                                     // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBlackboardKeySelector                 ConeOrigin;                                        // 0x0070(0x0028)(Edit, NativeAccessSpecifierPublic)
	struct FBlackboardKeySelector                 ConeDirection;                                     // 0x0098(0x0028)(Edit, NativeAccessSpecifierPublic)
	struct FBlackboardKeySelector                 Observed;                                          // 0x00C0(0x0028)(Edit, NativeAccessSpecifierPublic)
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_ConeCheck">();
	}
	static class UBTDecorator_ConeCheck* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_ConeCheck>();
	}
};
static_assert(alignof(UBTDecorator_ConeCheck) == 0x000008, "Wrong alignment on UBTDecorator_ConeCheck");
static_assert(sizeof(UBTDecorator_ConeCheck) == 0x0000F0, "Wrong size on UBTDecorator_ConeCheck");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeHalfAngle) == 0x000068, "Member 'UBTDecorator_ConeCheck::ConeHalfAngle' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeOrigin) == 0x000070, "Member 'UBTDecorator_ConeCheck::ConeOrigin' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeDirection) == 0x000098, "Member 'UBTDecorator_ConeCheck::ConeDirection' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, Observed) == 0x0000C0, "Member 'UBTDecorator_ConeCheck::Observed' has a wrong offset!");

// Class AIModule.BTDecorator_Cooldown
// 0x0008 (0x0070 - 0x0068)
class UBTDecorator_Cooldown final : public UBTDecorator
{
public:
	float                                         CooldownTime;                                      // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_Cooldown">();
	}
	static class UBTDecorator_Cooldown* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_Cooldown>();
	}
};
static_assert(alignof(UBTDecorator_Cooldown) == 0x000008, "Wrong alignment on UBTDecorator_Cooldown");
static_assert(sizeof(UBTDecorator_Cooldown) == 0x000070, "Wrong size on UBTDecorator_Cooldown");
static_assert(offsetof(UBTDecorator_Cooldown, CooldownTime) == 0x000068, "Member 'UBTDecorator_Cooldown::CooldownTime' has a wrong offset!");

// Class AIModule.BTDecorator_DoesPathExist
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_DoesPathExist final : public UBTDecorator
{
public:
	struct FBlackboardKeySelector                 BlackboardKeyA;                                    // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
	struct FBlackboardKeySelector                 BlackboardKeyB;                                    // 0x0090(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
	uint8                                         bUseSelf : 1;                                      // 0x00B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B9[0x3];                                       // 0x00B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EPathExistanceQueryType                       PathQueryType;                                     // 0x00BC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavigationQueryFilter>     FilterClass;                                       // 0x00C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_DoesPathExist">();
	}
	static class UBTDecorator_DoesPathExist* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_DoesPathExist>();
	}
};
static_assert(alignof(UBTDecorator_DoesPathExist) == 0x000008, "Wrong alignment on UBTDecorator_DoesPathExist");
static_assert(sizeof(UBTDecorator_DoesPathExist) == 0x0000C8, "Wrong size on UBTDecorator_DoesPathExist");
static_assert(offsetof(UBTDecorator_DoesPathExist, BlackboardKeyA) == 0x000068, "Member 'UBTDecorator_DoesPathExist::BlackboardKeyA' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, BlackboardKeyB) == 0x000090, "Member 'UBTDecorator_DoesPathExist::BlackboardKeyB' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, PathQueryType) == 0x0000BC, "Member 'UBTDecorator_DoesPathExist::PathQueryType' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, FilterClass) == 0x0000C0, "Member 'UBTDecorator_DoesPathExist::FilterClass' has a wrong offset!");

// Class AIModule.PawnAction_Repeat
// 0x0020 (0x00B0 - 0x0090)
class UPawnAction_Repeat final : public UPawnAction
{
public:
	class UPawnAction*                            ActionToRepeat;                                    // 0x0090(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPawnAction*                            RecentActionCopy;                                  // 0x0098(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPawnActionFailHandling                       ChildFailureHandlingMode;                          // 0x00A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A1[0xF];                                       // 0x00A1(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnAction_Repeat">();
	}
	static class UPawnAction_Repeat* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnAction_Repeat>();
	}
};
static_assert(alignof(UPawnAction_Repeat) == 0x000008, "Wrong alignment on UPawnAction_Repeat");
static_assert(sizeof(UPawnAction_Repeat) == 0x0000B0, "Wrong size on UPawnAction_Repeat");
static_assert(offsetof(UPawnAction_Repeat, ActionToRepeat) == 0x000090, "Member 'UPawnAction_Repeat::ActionToRepeat' has a wrong offset!");
static_assert(offsetof(UPawnAction_Repeat, RecentActionCopy) == 0x000098, "Member 'UPawnAction_Repeat::RecentActionCopy' has a wrong offset!");
static_assert(offsetof(UPawnAction_Repeat, ChildFailureHandlingMode) == 0x0000A0, "Member 'UPawnAction_Repeat::ChildFailureHandlingMode' has a wrong offset!");

// Class AIModule.BTDecorator_ForceSuccess
// 0x0000 (0x0068 - 0x0068)
class UBTDecorator_ForceSuccess final : public UBTDecorator
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_ForceSuccess">();
	}
	static class UBTDecorator_ForceSuccess* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_ForceSuccess>();
	}
};
static_assert(alignof(UBTDecorator_ForceSuccess) == 0x000008, "Wrong alignment on UBTDecorator_ForceSuccess");
static_assert(sizeof(UBTDecorator_ForceSuccess) == 0x000068, "Wrong size on UBTDecorator_ForceSuccess");

// Class AIModule.BTDecorator_IsAtLocation
// 0x0048 (0x00D8 - 0x0090)
class UBTDecorator_IsAtLocation final : public UBTDecorator_BlackboardBase
{
public:
	float                                         AcceptableRadius;                                  // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_94[0x4];                                       // 0x0094(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAIDataProviderFloatValue              ParametrizedAcceptableRadius;                      // 0x0098(0x0038)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EFAIDistanceType                              GeometricDistanceType;                             // 0x00D0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D1[0x3];                                       // 0x00D1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseParametrizedRadius : 1;                        // 0x00D4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseNavAgentGoalLocation : 1;                      // 0x00D4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPathFindingBasedTest : 1;                         // 0x00D4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D5[0x3];                                       // 0x00D5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_IsAtLocation">();
	}
	static class UBTDecorator_IsAtLocation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_IsAtLocation>();
	}
};
static_assert(alignof(UBTDecorator_IsAtLocation) == 0x000008, "Wrong alignment on UBTDecorator_IsAtLocation");
static_assert(sizeof(UBTDecorator_IsAtLocation) == 0x0000D8, "Wrong size on UBTDecorator_IsAtLocation");
static_assert(offsetof(UBTDecorator_IsAtLocation, AcceptableRadius) == 0x000090, "Member 'UBTDecorator_IsAtLocation::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTDecorator_IsAtLocation, ParametrizedAcceptableRadius) == 0x000098, "Member 'UBTDecorator_IsAtLocation::ParametrizedAcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTDecorator_IsAtLocation, GeometricDistanceType) == 0x0000D0, "Member 'UBTDecorator_IsAtLocation::GeometricDistanceType' has a wrong offset!");

// Class AIModule.BTDecorator_IsBBEntryOfClass
// 0x0008 (0x0098 - 0x0090)
class UBTDecorator_IsBBEntryOfClass final : public UBTDecorator_BlackboardBase
{
public:
	TSubclassOf<class UObject>                    TestClass;                                         // 0x0090(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_IsBBEntryOfClass">();
	}
	static class UBTDecorator_IsBBEntryOfClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_IsBBEntryOfClass>();
	}
};
static_assert(alignof(UBTDecorator_IsBBEntryOfClass) == 0x000008, "Wrong alignment on UBTDecorator_IsBBEntryOfClass");
static_assert(sizeof(UBTDecorator_IsBBEntryOfClass) == 0x000098, "Wrong size on UBTDecorator_IsBBEntryOfClass");
static_assert(offsetof(UBTDecorator_IsBBEntryOfClass, TestClass) == 0x000090, "Member 'UBTDecorator_IsBBEntryOfClass::TestClass' has a wrong offset!");

// Class AIModule.BTDecorator_KeepInCone
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_KeepInCone final : public UBTDecorator
{
public:
	float                                         ConeHalfAngle;                                     // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBlackboardKeySelector                 ConeOrigin;                                        // 0x0070(0x0028)(Edit, NativeAccessSpecifierPublic)
	struct FBlackboardKeySelector                 Observed;                                          // 0x0098(0x0028)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bUseSelfAsOrigin : 1;                              // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseSelfAsObserved : 1;                            // 0x00C0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_KeepInCone">();
	}
	static class UBTDecorator_KeepInCone* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_KeepInCone>();
	}
};
static_assert(alignof(UBTDecorator_KeepInCone) == 0x000008, "Wrong alignment on UBTDecorator_KeepInCone");
static_assert(sizeof(UBTDecorator_KeepInCone) == 0x0000C8, "Wrong size on UBTDecorator_KeepInCone");
static_assert(offsetof(UBTDecorator_KeepInCone, ConeHalfAngle) == 0x000068, "Member 'UBTDecorator_KeepInCone::ConeHalfAngle' has a wrong offset!");
static_assert(offsetof(UBTDecorator_KeepInCone, ConeOrigin) == 0x000070, "Member 'UBTDecorator_KeepInCone::ConeOrigin' has a wrong offset!");
static_assert(offsetof(UBTDecorator_KeepInCone, Observed) == 0x000098, "Member 'UBTDecorator_KeepInCone::Observed' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_OnCircle
// 0x0190 (0x0210 - 0x0080)
class UEnvQueryGenerator_OnCircle final : public UEnvQueryGenerator_ProjectedPoints
{
public:
	struct FAIDataProviderFloatValue              CircleRadius;                                      // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              SpaceBetween;                                      // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderIntValue                NumberOfPoints;                                    // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EPointOnCircleSpacingMethod                   PointOnCircleSpacingMethod;                        // 0x0128(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_129[0x7];                                      // 0x0129(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEnvDirection                          ArcDirection;                                      // 0x0130(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ArcAngle;                                          // 0x0150(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         AngleRadians;                                      // 0x0188(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_18C[0x4];                                      // 0x018C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryContext>           CircleCenter;                                      // 0x0190(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIgnoreAnyContextActorsWhenGeneratingCircle;       // 0x0198(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_199[0x7];                                      // 0x0199(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAIDataProviderFloatValue              CircleCenterZOffset;                               // 0x01A0(0x0038)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FEnvTraceData                          TraceData;                                         // 0x01D8(0x0030)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bDefineArc : 1;                                    // 0x0208(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_209[0x7];                                      // 0x0209(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_OnCircle">();
	}
	static class UEnvQueryGenerator_OnCircle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_OnCircle>();
	}
};
static_assert(alignof(UEnvQueryGenerator_OnCircle) == 0x000008, "Wrong alignment on UEnvQueryGenerator_OnCircle");
static_assert(sizeof(UEnvQueryGenerator_OnCircle) == 0x000210, "Wrong size on UEnvQueryGenerator_OnCircle");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleRadius) == 0x000080, "Member 'UEnvQueryGenerator_OnCircle::CircleRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, SpaceBetween) == 0x0000B8, "Member 'UEnvQueryGenerator_OnCircle::SpaceBetween' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, NumberOfPoints) == 0x0000F0, "Member 'UEnvQueryGenerator_OnCircle::NumberOfPoints' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, PointOnCircleSpacingMethod) == 0x000128, "Member 'UEnvQueryGenerator_OnCircle::PointOnCircleSpacingMethod' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, ArcDirection) == 0x000130, "Member 'UEnvQueryGenerator_OnCircle::ArcDirection' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, ArcAngle) == 0x000150, "Member 'UEnvQueryGenerator_OnCircle::ArcAngle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, AngleRadians) == 0x000188, "Member 'UEnvQueryGenerator_OnCircle::AngleRadians' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleCenter) == 0x000190, "Member 'UEnvQueryGenerator_OnCircle::CircleCenter' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, bIgnoreAnyContextActorsWhenGeneratingCircle) == 0x000198, "Member 'UEnvQueryGenerator_OnCircle::bIgnoreAnyContextActorsWhenGeneratingCircle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleCenterZOffset) == 0x0001A0, "Member 'UEnvQueryGenerator_OnCircle::CircleCenterZOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, TraceData) == 0x0001D8, "Member 'UEnvQueryGenerator_OnCircle::TraceData' has a wrong offset!");

// Class AIModule.BTDecorator_Loop
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_Loop final : public UBTDecorator
{
public:
	int32                                         NumLoops;                                          // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInfiniteLoop;                                     // 0x006C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6D[0x3];                                       // 0x006D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InfiniteLoopTimeoutTime;                           // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_74[0x4];                                       // 0x0074(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_Loop">();
	}
	static class UBTDecorator_Loop* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_Loop>();
	}
};
static_assert(alignof(UBTDecorator_Loop) == 0x000008, "Wrong alignment on UBTDecorator_Loop");
static_assert(sizeof(UBTDecorator_Loop) == 0x000078, "Wrong size on UBTDecorator_Loop");
static_assert(offsetof(UBTDecorator_Loop, NumLoops) == 0x000068, "Member 'UBTDecorator_Loop::NumLoops' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Loop, bInfiniteLoop) == 0x00006C, "Member 'UBTDecorator_Loop::bInfiniteLoop' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Loop, InfiniteLoopTimeoutTime) == 0x000070, "Member 'UBTDecorator_Loop::InfiniteLoopTimeoutTime' has a wrong offset!");

// Class AIModule.BTDecorator_ReachedMoveGoal
// 0x0000 (0x0068 - 0x0068)
class UBTDecorator_ReachedMoveGoal final : public UBTDecorator
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_ReachedMoveGoal">();
	}
	static class UBTDecorator_ReachedMoveGoal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_ReachedMoveGoal>();
	}
};
static_assert(alignof(UBTDecorator_ReachedMoveGoal) == 0x000008, "Wrong alignment on UBTDecorator_ReachedMoveGoal");
static_assert(sizeof(UBTDecorator_ReachedMoveGoal) == 0x000068, "Wrong size on UBTDecorator_ReachedMoveGoal");

// Class AIModule.BTDecorator_SetTagCooldown
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_SetTagCooldown final : public UBTDecorator
{
public:
	struct FGameplayTag                           CooldownTag;                                       // 0x0068(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CooldownDuration;                                  // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAddToExistingDuration;                            // 0x0074(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_75[0x3];                                       // 0x0075(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_SetTagCooldown">();
	}
	static class UBTDecorator_SetTagCooldown* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_SetTagCooldown>();
	}
};
static_assert(alignof(UBTDecorator_SetTagCooldown) == 0x000008, "Wrong alignment on UBTDecorator_SetTagCooldown");
static_assert(sizeof(UBTDecorator_SetTagCooldown) == 0x000078, "Wrong size on UBTDecorator_SetTagCooldown");
static_assert(offsetof(UBTDecorator_SetTagCooldown, CooldownTag) == 0x000068, "Member 'UBTDecorator_SetTagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTDecorator_SetTagCooldown, CooldownDuration) == 0x000070, "Member 'UBTDecorator_SetTagCooldown::CooldownDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_SetTagCooldown, bAddToExistingDuration) == 0x000074, "Member 'UBTDecorator_SetTagCooldown::bAddToExistingDuration' has a wrong offset!");

// Class AIModule.BTDecorator_TagCooldown
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_TagCooldown final : public UBTDecorator
{
public:
	struct FGameplayTag                           CooldownTag;                                       // 0x0068(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CooldownDuration;                                  // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAddToExistingDuration;                            // 0x0074(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bActivatesCooldown;                                // 0x0075(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_76[0x2];                                       // 0x0076(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTDecorator_TagCooldown">();
	}
	static class UBTDecorator_TagCooldown* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTDecorator_TagCooldown>();
	}
};
static_assert(alignof(UBTDecorator_TagCooldown) == 0x000008, "Wrong alignment on UBTDecorator_TagCooldown");
static_assert(sizeof(UBTDecorator_TagCooldown) == 0x000078, "Wrong size on UBTDecorator_TagCooldown");
static_assert(offsetof(UBTDecorator_TagCooldown, CooldownTag) == 0x000068, "Member 'UBTDecorator_TagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, CooldownDuration) == 0x000070, "Member 'UBTDecorator_TagCooldown::CooldownDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, bAddToExistingDuration) == 0x000074, "Member 'UBTDecorator_TagCooldown::bAddToExistingDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, bActivatesCooldown) == 0x000075, "Member 'UBTDecorator_TagCooldown::bActivatesCooldown' has a wrong offset!");

// Class AIModule.BTFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UBTFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void ClearBlackboardValue(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static void ClearBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class AActor* GetBlackboardValueAsActor(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static bool GetBlackboardValueAsBool(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class UClass* GetBlackboardValueAsClass(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static uint8 GetBlackboardValueAsEnum(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static float GetBlackboardValueAsFloat(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static int32 GetBlackboardValueAsInt(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class FName GetBlackboardValueAsName(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class UObject* GetBlackboardValueAsObject(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static struct FRotator GetBlackboardValueAsRotator(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class FString GetBlackboardValueAsString(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static struct FVector GetBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
	static class UBehaviorTreeComponent* GetOwnerComponent(class UBTNode* NodeOwner);
	static class UBlackboardComponent* GetOwnersBlackboard(class UBTNode* NodeOwner);
	static void SetBlackboardValueAsBool(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, bool Value);
	static void SetBlackboardValueAsClass(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class UClass* Value);
	static void SetBlackboardValueAsEnum(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, uint8 Value);
	static void SetBlackboardValueAsFloat(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, float Value);
	static void SetBlackboardValueAsInt(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, int32 Value);
	static void SetBlackboardValueAsName(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class FName Value);
	static void SetBlackboardValueAsObject(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class UObject* Value);
	static void SetBlackboardValueAsRotator(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const struct FRotator& Value);
	static void SetBlackboardValueAsString(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const class FString& Value);
	static void SetBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const struct FVector& Value);
	static void StartUsingExternalEvent(class UBTNode* NodeOwner, class AActor* OwningActor);
	static void StopUsingExternalEvent(class UBTNode* NodeOwner);

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

// Class AIModule.BTService_BlackboardBase
// 0x0028 (0x0098 - 0x0070)
class UBTService_BlackboardBase : public UBTService
{
public:
	struct FBlackboardKeySelector                 BlackboardKey;                                     // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTService_BlackboardBase">();
	}
	static class UBTService_BlackboardBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTService_BlackboardBase>();
	}
};
static_assert(alignof(UBTService_BlackboardBase) == 0x000008, "Wrong alignment on UBTService_BlackboardBase");
static_assert(sizeof(UBTService_BlackboardBase) == 0x000098, "Wrong size on UBTService_BlackboardBase");
static_assert(offsetof(UBTService_BlackboardBase, BlackboardKey) == 0x000070, "Member 'UBTService_BlackboardBase::BlackboardKey' has a wrong offset!");

// Class AIModule.BTService_BlueprintBase
// 0x0028 (0x0098 - 0x0070)
class UBTService_BlueprintBase final : public UBTService
{
public:
	class AAIController*                          AIOwner;                                           // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 ActorOwner;                                        // 0x0078(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_80[0x10];                                      // 0x0080(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bShowPropertyDetails : 1;                          // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bShowEventDetails : 1;                             // 0x0090(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ReceiveActivation(class AActor* OwnerActor);
	void ReceiveActivationAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveDeactivation(class AActor* OwnerActor);
	void ReceiveDeactivationAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveSearchStart(class AActor* OwnerActor);
	void ReceiveSearchStartAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
	void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);

	bool IsServiceActive() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTService_BlueprintBase">();
	}
	static class UBTService_BlueprintBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTService_BlueprintBase>();
	}
};
static_assert(alignof(UBTService_BlueprintBase) == 0x000008, "Wrong alignment on UBTService_BlueprintBase");
static_assert(sizeof(UBTService_BlueprintBase) == 0x000098, "Wrong size on UBTService_BlueprintBase");
static_assert(offsetof(UBTService_BlueprintBase, AIOwner) == 0x000070, "Member 'UBTService_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTService_BlueprintBase, ActorOwner) == 0x000078, "Member 'UBTService_BlueprintBase::ActorOwner' has a wrong offset!");

// Class AIModule.BTService_DefaultFocus
// 0x0008 (0x00A0 - 0x0098)
class UBTService_DefaultFocus final : public UBTService_BlackboardBase
{
public:
	uint8                                         FocusPriority;                                     // 0x0098(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTService_DefaultFocus">();
	}
	static class UBTService_DefaultFocus* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTService_DefaultFocus>();
	}
};
static_assert(alignof(UBTService_DefaultFocus) == 0x000008, "Wrong alignment on UBTService_DefaultFocus");
static_assert(sizeof(UBTService_DefaultFocus) == 0x0000A0, "Wrong size on UBTService_DefaultFocus");
static_assert(offsetof(UBTService_DefaultFocus, FocusPriority) == 0x000098, "Member 'UBTService_DefaultFocus::FocusPriority' has a wrong offset!");

// Class AIModule.BTService_RunEQS
// 0x0058 (0x00F0 - 0x0098)
class UBTService_RunEQS final : public UBTService_BlackboardBase
{
public:
	struct FEQSParametrizedQueryExecutionRequest  EQSRequest;                                        // 0x0098(0x0048)(Edit, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_E0[0x10];                                      // 0x00E0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTService_RunEQS">();
	}
	static class UBTService_RunEQS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTService_RunEQS>();
	}
};
static_assert(alignof(UBTService_RunEQS) == 0x000008, "Wrong alignment on UBTService_RunEQS");
static_assert(sizeof(UBTService_RunEQS) == 0x0000F0, "Wrong size on UBTService_RunEQS");
static_assert(offsetof(UBTService_RunEQS, EQSRequest) == 0x000098, "Member 'UBTService_RunEQS::EQSRequest' has a wrong offset!");

// Class AIModule.BTTask_BlackboardBase
// 0x0028 (0x0098 - 0x0070)
class UBTTask_BlackboardBase : public UBTTaskNode
{
public:
	struct FBlackboardKeySelector                 BlackboardKey;                                     // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_BlackboardBase">();
	}
	static class UBTTask_BlackboardBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_BlackboardBase>();
	}
};
static_assert(alignof(UBTTask_BlackboardBase) == 0x000008, "Wrong alignment on UBTTask_BlackboardBase");
static_assert(sizeof(UBTTask_BlackboardBase) == 0x000098, "Wrong size on UBTTask_BlackboardBase");
static_assert(offsetof(UBTTask_BlackboardBase, BlackboardKey) == 0x000070, "Member 'UBTTask_BlackboardBase::BlackboardKey' has a wrong offset!");

// Class AIModule.BTTask_BlueprintBase
// 0x0038 (0x00A8 - 0x0070)
class UBTTask_BlueprintBase final : public UBTTaskNode
{
public:
	class AAIController*                          AIOwner;                                           // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 ActorOwner;                                        // 0x0078(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FIntervalCountdown                     TickInterval;                                      // 0x0080(0x0008)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_88[0x18];                                      // 0x0088(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bShowPropertyDetails : 1;                          // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_A1[0x7];                                       // 0x00A1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void FinishAbort();
	void FinishExecute(bool bSuccess);
	void ReceiveAbort(class AActor* OwnerActor);
	void ReceiveAbortAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveExecute(class AActor* OwnerActor);
	void ReceiveExecuteAI(class AAIController* OwnerController, class APawn* ControlledPawn);
	void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
	void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);
	void SetFinishOnMessage(class FName MessageName);
	void SetFinishOnMessageWithId(class FName MessageName, int32 RequestID);

	bool IsTaskAborting() const;
	bool IsTaskExecuting() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_BlueprintBase">();
	}
	static class UBTTask_BlueprintBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_BlueprintBase>();
	}
};
static_assert(alignof(UBTTask_BlueprintBase) == 0x000008, "Wrong alignment on UBTTask_BlueprintBase");
static_assert(sizeof(UBTTask_BlueprintBase) == 0x0000A8, "Wrong size on UBTTask_BlueprintBase");
static_assert(offsetof(UBTTask_BlueprintBase, AIOwner) == 0x000070, "Member 'UBTTask_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTTask_BlueprintBase, ActorOwner) == 0x000078, "Member 'UBTTask_BlueprintBase::ActorOwner' has a wrong offset!");
static_assert(offsetof(UBTTask_BlueprintBase, TickInterval) == 0x000080, "Member 'UBTTask_BlueprintBase::TickInterval' has a wrong offset!");

// Class AIModule.BTTask_FinishWithResult
// 0x0008 (0x0078 - 0x0070)
class UBTTask_FinishWithResult final : public UBTTaskNode
{
public:
	EBTNodeResult                                 Result;                                            // 0x0070(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_FinishWithResult">();
	}
	static class UBTTask_FinishWithResult* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_FinishWithResult>();
	}
};
static_assert(alignof(UBTTask_FinishWithResult) == 0x000008, "Wrong alignment on UBTTask_FinishWithResult");
static_assert(sizeof(UBTTask_FinishWithResult) == 0x000078, "Wrong size on UBTTask_FinishWithResult");
static_assert(offsetof(UBTTask_FinishWithResult, Result) == 0x000070, "Member 'UBTTask_FinishWithResult::Result' has a wrong offset!");

// Class AIModule.BTTask_MoveTo
// 0x0018 (0x00B0 - 0x0098)
class UBTTask_MoveTo : public UBTTask_BlackboardBase
{
public:
	float                                         AcceptableRadius;                                  // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavigationQueryFilter>     FilterClass;                                       // 0x00A0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ObservedBlackboardValueTolerance;                  // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bObserveBlackboardValue : 1;                       // 0x00AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowStrafe : 1;                                  // 0x00AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowPartialPath : 1;                             // 0x00AC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTrackMovingGoal : 1;                              // 0x00AC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bProjectGoalLocation : 1;                          // 0x00AC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReachTestIncludesAgentRadius : 1;                 // 0x00AC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReachTestIncludesGoalRadius : 1;                  // 0x00AC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStopOnOverlap : 1;                                // 0x00AC(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStopOnOverlapNeedsUpdate : 1;                     // 0x00AD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_AE[0x2];                                       // 0x00AE(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_MoveTo">();
	}
	static class UBTTask_MoveTo* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_MoveTo>();
	}
};
static_assert(alignof(UBTTask_MoveTo) == 0x000008, "Wrong alignment on UBTTask_MoveTo");
static_assert(sizeof(UBTTask_MoveTo) == 0x0000B0, "Wrong size on UBTTask_MoveTo");
static_assert(offsetof(UBTTask_MoveTo, AcceptableRadius) == 0x000098, "Member 'UBTTask_MoveTo::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTTask_MoveTo, FilterClass) == 0x0000A0, "Member 'UBTTask_MoveTo::FilterClass' has a wrong offset!");
static_assert(offsetof(UBTTask_MoveTo, ObservedBlackboardValueTolerance) == 0x0000A8, "Member 'UBTTask_MoveTo::ObservedBlackboardValueTolerance' has a wrong offset!");

// Class AIModule.BTTask_MoveDirectlyToward
// 0x0008 (0x00B8 - 0x00B0)
class UBTTask_MoveDirectlyToward final : public UBTTask_MoveTo
{
public:
	uint8                                         bDisablePathUpdateOnGoalLocationChange : 1;        // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bProjectVectorGoalToNavigation : 1;                // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdatedDeprecatedProperties : 1;                  // 0x00B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.BTTask_PawnActionBase
// 0x0000 (0x0070 - 0x0070)
class UBTTask_PawnActionBase : public UBTTaskNode
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_PawnActionBase">();
	}
	static class UBTTask_PawnActionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_PawnActionBase>();
	}
};
static_assert(alignof(UBTTask_PawnActionBase) == 0x000008, "Wrong alignment on UBTTask_PawnActionBase");
static_assert(sizeof(UBTTask_PawnActionBase) == 0x000070, "Wrong size on UBTTask_PawnActionBase");

// Class AIModule.BTTask_PlayAnimation
// 0x0040 (0x00B0 - 0x0070)
class UBTTask_PlayAnimation final : public UBTTaskNode
{
public:
	class UAnimationAsset*                        AnimationToPlay;                                   // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLooping : 1;                                      // 0x0078(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNonBlocking : 1;                                  // 0x0078(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_79[0x7];                                       // 0x0079(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UBehaviorTreeComponent*                 MyOwnerComp;                                       // 0x0080(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USkeletalMeshComponent*                 CachedSkelMesh;                                    // 0x0088(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x20];                                      // 0x0090(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_PlayAnimation">();
	}
	static class UBTTask_PlayAnimation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_PlayAnimation>();
	}
};
static_assert(alignof(UBTTask_PlayAnimation) == 0x000008, "Wrong alignment on UBTTask_PlayAnimation");
static_assert(sizeof(UBTTask_PlayAnimation) == 0x0000B0, "Wrong size on UBTTask_PlayAnimation");
static_assert(offsetof(UBTTask_PlayAnimation, AnimationToPlay) == 0x000070, "Member 'UBTTask_PlayAnimation::AnimationToPlay' has a wrong offset!");
static_assert(offsetof(UBTTask_PlayAnimation, MyOwnerComp) == 0x000080, "Member 'UBTTask_PlayAnimation::MyOwnerComp' has a wrong offset!");
static_assert(offsetof(UBTTask_PlayAnimation, CachedSkelMesh) == 0x000088, "Member 'UBTTask_PlayAnimation::CachedSkelMesh' has a wrong offset!");

// Class AIModule.BTTask_PlaySound
// 0x0008 (0x0078 - 0x0070)
class UBTTask_PlaySound final : public UBTTaskNode
{
public:
	class USoundCue*                              SoundToPlay;                                       // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_PlaySound">();
	}
	static class UBTTask_PlaySound* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_PlaySound>();
	}
};
static_assert(alignof(UBTTask_PlaySound) == 0x000008, "Wrong alignment on UBTTask_PlaySound");
static_assert(sizeof(UBTTask_PlaySound) == 0x000078, "Wrong size on UBTTask_PlaySound");
static_assert(offsetof(UBTTask_PlaySound, SoundToPlay) == 0x000070, "Member 'UBTTask_PlaySound::SoundToPlay' has a wrong offset!");

// Class AIModule.BTTask_PushPawnAction
// 0x0008 (0x0078 - 0x0070)
class UBTTask_PushPawnAction final : public UBTTask_PawnActionBase
{
public:
	class UPawnAction*                            Action;                                            // 0x0070(0x0008)(Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_PushPawnAction">();
	}
	static class UBTTask_PushPawnAction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_PushPawnAction>();
	}
};
static_assert(alignof(UBTTask_PushPawnAction) == 0x000008, "Wrong alignment on UBTTask_PushPawnAction");
static_assert(sizeof(UBTTask_PushPawnAction) == 0x000078, "Wrong size on UBTTask_PushPawnAction");
static_assert(offsetof(UBTTask_PushPawnAction, Action) == 0x000070, "Member 'UBTTask_PushPawnAction::Action' has a wrong offset!");

// Class AIModule.BTTask_RotateToFaceBBEntry
// 0x0008 (0x00A0 - 0x0098)
class UBTTask_RotateToFaceBBEntry final : public UBTTask_BlackboardBase
{
public:
	float                                         Precision;                                         // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_RotateToFaceBBEntry">();
	}
	static class UBTTask_RotateToFaceBBEntry* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_RotateToFaceBBEntry>();
	}
};
static_assert(alignof(UBTTask_RotateToFaceBBEntry) == 0x000008, "Wrong alignment on UBTTask_RotateToFaceBBEntry");
static_assert(sizeof(UBTTask_RotateToFaceBBEntry) == 0x0000A0, "Wrong size on UBTTask_RotateToFaceBBEntry");
static_assert(offsetof(UBTTask_RotateToFaceBBEntry, Precision) == 0x000098, "Member 'UBTTask_RotateToFaceBBEntry::Precision' has a wrong offset!");

// Class AIModule.BTTask_RunEQSQuery
// 0x00B8 (0x0150 - 0x0098)
class UBTTask_RunEQSQuery final : public UBTTask_BlackboardBase
{
public:
	class UEnvQuery*                              QueryTemplate;                                     // 0x0098(0x0008)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FEnvNamedValue>                 QueryParams;                                       // 0x00A0(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
	TArray<struct FAIDynamicParam>                QueryConfig;                                       // 0x00B0(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
	EEnvQueryRunMode                              RunMode;                                           // 0x00C0(0x0001)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBlackboardKeySelector                 EQSQueryBlackboardKey;                             // 0x00C8(0x0028)(Edit, EditConst, NativeAccessSpecifierPublic)
	bool                                          bUseBBKey;                                         // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F1[0x7];                                       // 0x00F1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEQSParametrizedQueryExecutionRequest  EQSRequest;                                        // 0x00F8(0x0048)(Edit, NativeAccessSpecifierPublic)
	uint8                                         Pad_140[0x10];                                     // 0x0140(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_RunEQSQuery">();
	}
	static class UBTTask_RunEQSQuery* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_RunEQSQuery>();
	}
};
static_assert(alignof(UBTTask_RunEQSQuery) == 0x000008, "Wrong alignment on UBTTask_RunEQSQuery");
static_assert(sizeof(UBTTask_RunEQSQuery) == 0x000150, "Wrong size on UBTTask_RunEQSQuery");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryTemplate) == 0x000098, "Member 'UBTTask_RunEQSQuery::QueryTemplate' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryParams) == 0x0000A0, "Member 'UBTTask_RunEQSQuery::QueryParams' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryConfig) == 0x0000B0, "Member 'UBTTask_RunEQSQuery::QueryConfig' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, RunMode) == 0x0000C0, "Member 'UBTTask_RunEQSQuery::RunMode' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, EQSQueryBlackboardKey) == 0x0000C8, "Member 'UBTTask_RunEQSQuery::EQSQueryBlackboardKey' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, bUseBBKey) == 0x0000F0, "Member 'UBTTask_RunEQSQuery::bUseBBKey' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, EQSRequest) == 0x0000F8, "Member 'UBTTask_RunEQSQuery::EQSRequest' has a wrong offset!");

// Class AIModule.BTTask_SetTagCooldown
// 0x0010 (0x0080 - 0x0070)
class UBTTask_SetTagCooldown final : public UBTTaskNode
{
public:
	struct FGameplayTag                           CooldownTag;                                       // 0x0070(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAddToExistingDuration;                            // 0x0078(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_79[0x3];                                       // 0x0079(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CooldownDuration;                                  // 0x007C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BTTask_SetTagCooldown">();
	}
	static class UBTTask_SetTagCooldown* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBTTask_SetTagCooldown>();
	}
};
static_assert(alignof(UBTTask_SetTagCooldown) == 0x000008, "Wrong alignment on UBTTask_SetTagCooldown");
static_assert(sizeof(UBTTask_SetTagCooldown) == 0x000080, "Wrong size on UBTTask_SetTagCooldown");
static_assert(offsetof(UBTTask_SetTagCooldown, CooldownTag) == 0x000070, "Member 'UBTTask_SetTagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTTask_SetTagCooldown, bAddToExistingDuration) == 0x000078, "Member 'UBTTask_SetTagCooldown::bAddToExistingDuration' has a wrong offset!");
static_assert(offsetof(UBTTask_SetTagCooldown, CooldownDuration) == 0x00007C, "Member 'UBTTask_SetTagCooldown::CooldownDuration' has a wrong offset!");

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

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

// Class AIModule.CrowdManager
// 0x00B0 (0x00D8 - 0x0028)
class UCrowdManager final : public UCrowdManagerBase
{
public:
	class ANavigationData*                        MyNavData;                                         // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FCrowdAvoidanceConfig>          AvoidanceConfig;                                   // 0x0030(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	TArray<struct FCrowdAvoidanceSamplingPattern> SamplingPatterns;                                  // 0x0040(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	int32                                         MaxAgents;                                         // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MaxAgentRadius;                                    // 0x0054(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxAvoidedAgents;                                  // 0x0058(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxAvoidedWalls;                                   // 0x005C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         NavmeshCheckInterval;                              // 0x0060(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         PathOptimizationInterval;                          // 0x0064(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         SeparationDirClamp;                                // 0x0068(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         PathOffsetRadiusMultiplier;                        // 0x006C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         BitPad_70_0 : 4;                                   // 0x0070(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bResolveCollisions : 1;                            // 0x0070(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_71[0x67];                                      // 0x0071(0x0067)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CrowdManager">();
	}
	static class UCrowdManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCrowdManager>();
	}
};
static_assert(alignof(UCrowdManager) == 0x000008, "Wrong alignment on UCrowdManager");
static_assert(sizeof(UCrowdManager) == 0x0000D8, "Wrong size on UCrowdManager");
static_assert(offsetof(UCrowdManager, MyNavData) == 0x000028, "Member 'UCrowdManager::MyNavData' has a wrong offset!");
static_assert(offsetof(UCrowdManager, AvoidanceConfig) == 0x000030, "Member 'UCrowdManager::AvoidanceConfig' has a wrong offset!");
static_assert(offsetof(UCrowdManager, SamplingPatterns) == 0x000040, "Member 'UCrowdManager::SamplingPatterns' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAgents) == 0x000050, "Member 'UCrowdManager::MaxAgents' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAgentRadius) == 0x000054, "Member 'UCrowdManager::MaxAgentRadius' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAvoidedAgents) == 0x000058, "Member 'UCrowdManager::MaxAvoidedAgents' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAvoidedWalls) == 0x00005C, "Member 'UCrowdManager::MaxAvoidedWalls' has a wrong offset!");
static_assert(offsetof(UCrowdManager, NavmeshCheckInterval) == 0x000060, "Member 'UCrowdManager::NavmeshCheckInterval' has a wrong offset!");
static_assert(offsetof(UCrowdManager, PathOptimizationInterval) == 0x000064, "Member 'UCrowdManager::PathOptimizationInterval' has a wrong offset!");
static_assert(offsetof(UCrowdManager, SeparationDirClamp) == 0x000068, "Member 'UCrowdManager::SeparationDirClamp' has a wrong offset!");
static_assert(offsetof(UCrowdManager, PathOffsetRadiusMultiplier) == 0x00006C, "Member 'UCrowdManager::PathOffsetRadiusMultiplier' has a wrong offset!");

// Class AIModule.DetourCrowdAIController
// 0x0000 (0x0328 - 0x0328)
class ADetourCrowdAIController final : public AAIController
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DetourCrowdAIController">();
	}
	static class ADetourCrowdAIController* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADetourCrowdAIController>();
	}
};
static_assert(alignof(ADetourCrowdAIController) == 0x000008, "Wrong alignment on ADetourCrowdAIController");
static_assert(sizeof(ADetourCrowdAIController) == 0x000328, "Wrong size on ADetourCrowdAIController");

// Class AIModule.EnvQuery
// 0x0018 (0x0048 - 0x0030)
class UEnvQuery final : public UDataAsset
{
public:
	class FName                                   QueryName;                                         // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UEnvQueryOption*>                Options;                                           // 0x0038(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)

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

// Class AIModule.EnvQueryContext_BlueprintBase
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryContext_BlueprintBase final : public UEnvQueryContext
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ProvideActorsSet(class UObject* QuerierObject, class AActor* QuerierActor, TArray<class AActor*>* ResultingActorsSet) const;
	void ProvideLocationsSet(class UObject* QuerierObject, class AActor* QuerierActor, TArray<struct FVector>* ResultingLocationSet) const;
	void ProvideSingleActor(class UObject* QuerierObject, class AActor* QuerierActor, class AActor** ResultingActor) const;
	void ProvideSingleLocation(class UObject* QuerierObject, class AActor* QuerierActor, struct FVector* ResultingLocation) const;

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

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

// Class AIModule.EnvQueryGenerator_ActorsOfClass
// 0x0080 (0x00D0 - 0x0050)
class UEnvQueryGenerator_ActorsOfClass final : public UEnvQueryGenerator
{
public:
	TSubclassOf<class AActor>                     SearchedActorClass;                                // 0x0050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIDataProviderBoolValue               GenerateOnlyActorsInRadius;                        // 0x0058(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              SearchRadius;                                      // 0x0090(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryContext>           SearchCenter;                                      // 0x00C8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_ActorsOfClass">();
	}
	static class UEnvQueryGenerator_ActorsOfClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_ActorsOfClass>();
	}
};
static_assert(alignof(UEnvQueryGenerator_ActorsOfClass) == 0x000008, "Wrong alignment on UEnvQueryGenerator_ActorsOfClass");
static_assert(sizeof(UEnvQueryGenerator_ActorsOfClass) == 0x0000D0, "Wrong size on UEnvQueryGenerator_ActorsOfClass");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchedActorClass) == 0x000050, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchedActorClass' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, GenerateOnlyActorsInRadius) == 0x000058, "Member 'UEnvQueryGenerator_ActorsOfClass::GenerateOnlyActorsInRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchRadius) == 0x000090, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchCenter) == 0x0000C8, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchCenter' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_BlueprintBase
// 0x0030 (0x0080 - 0x0050)
class UEnvQueryGenerator_BlueprintBase final : public UEnvQueryGenerator
{
public:
	class FText                                   GeneratorsActionDescription;                       // 0x0050(0x0018)(Edit, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryContext>           Context;                                           // 0x0068(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryItemType>          GeneratedItemType;                                 // 0x0070(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x8];                                       // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddGeneratedActor(class AActor* GeneratedActor) const;
	void AddGeneratedVector(const struct FVector& GeneratedVector) const;
	void DoItemGeneration(const TArray<struct FVector>& ContextLocations) const;
	class UObject* GetQuerier() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_BlueprintBase">();
	}
	static class UEnvQueryGenerator_BlueprintBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_BlueprintBase>();
	}
};
static_assert(alignof(UEnvQueryGenerator_BlueprintBase) == 0x000008, "Wrong alignment on UEnvQueryGenerator_BlueprintBase");
static_assert(sizeof(UEnvQueryGenerator_BlueprintBase) == 0x000080, "Wrong size on UEnvQueryGenerator_BlueprintBase");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, GeneratorsActionDescription) == 0x000050, "Member 'UEnvQueryGenerator_BlueprintBase::GeneratorsActionDescription' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, Context) == 0x000068, "Member 'UEnvQueryGenerator_BlueprintBase::Context' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, GeneratedItemType) == 0x000070, "Member 'UEnvQueryGenerator_BlueprintBase::GeneratedItemType' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_Composite
// 0x0020 (0x0070 - 0x0050)
class UEnvQueryGenerator_Composite final : public UEnvQueryGenerator
{
public:
	TArray<class UEnvQueryGenerator*>             Generators;                                        // 0x0050(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAllowDifferentItemTypes : 1;                      // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasMatchingItemType : 1;                          // 0x0060(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryItemType>          ForcedItemType;                                    // 0x0068(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_Composite">();
	}
	static class UEnvQueryGenerator_Composite* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_Composite>();
	}
};
static_assert(alignof(UEnvQueryGenerator_Composite) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Composite");
static_assert(sizeof(UEnvQueryGenerator_Composite) == 0x000070, "Wrong size on UEnvQueryGenerator_Composite");
static_assert(offsetof(UEnvQueryGenerator_Composite, Generators) == 0x000050, "Member 'UEnvQueryGenerator_Composite::Generators' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Composite, ForcedItemType) == 0x000068, "Member 'UEnvQueryGenerator_Composite::ForcedItemType' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_CurrentLocation
// 0x0008 (0x0058 - 0x0050)
class UEnvQueryGenerator_CurrentLocation final : public UEnvQueryGenerator
{
public:
	TSubclassOf<class UEnvQueryContext>           QueryContext;                                      // 0x0050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_CurrentLocation">();
	}
	static class UEnvQueryGenerator_CurrentLocation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_CurrentLocation>();
	}
};
static_assert(alignof(UEnvQueryGenerator_CurrentLocation) == 0x000008, "Wrong alignment on UEnvQueryGenerator_CurrentLocation");
static_assert(sizeof(UEnvQueryGenerator_CurrentLocation) == 0x000058, "Wrong size on UEnvQueryGenerator_CurrentLocation");
static_assert(offsetof(UEnvQueryGenerator_CurrentLocation, QueryContext) == 0x000050, "Member 'UEnvQueryGenerator_CurrentLocation::QueryContext' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_SimpleGrid
// 0x0078 (0x00F8 - 0x0080)
class UEnvQueryGenerator_SimpleGrid : public UEnvQueryGenerator_ProjectedPoints
{
public:
	struct FAIDataProviderFloatValue              GridSize;                                          // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              SpaceBetween;                                      // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryContext>           GenerateAround;                                    // 0x00F0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_SimpleGrid">();
	}
	static class UEnvQueryGenerator_SimpleGrid* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_SimpleGrid>();
	}
};
static_assert(alignof(UEnvQueryGenerator_SimpleGrid) == 0x000008, "Wrong alignment on UEnvQueryGenerator_SimpleGrid");
static_assert(sizeof(UEnvQueryGenerator_SimpleGrid) == 0x0000F8, "Wrong size on UEnvQueryGenerator_SimpleGrid");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, GridSize) == 0x000080, "Member 'UEnvQueryGenerator_SimpleGrid::GridSize' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, SpaceBetween) == 0x0000B8, "Member 'UEnvQueryGenerator_SimpleGrid::SpaceBetween' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, GenerateAround) == 0x0000F0, "Member 'UEnvQueryGenerator_SimpleGrid::GenerateAround' has a wrong offset!");

// Class AIModule.EnvQueryGenerator_PathingGrid
// 0x0078 (0x0170 - 0x00F8)
class UEnvQueryGenerator_PathingGrid final : public UEnvQueryGenerator_SimpleGrid
{
public:
	struct FAIDataProviderBoolValue               PathToItem;                                        // 0x00F8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavigationQueryFilter>     NavigationFilter;                                  // 0x0130(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ScanRangeMultiplier;                               // 0x0138(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryGenerator_PathingGrid">();
	}
	static class UEnvQueryGenerator_PathingGrid* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryGenerator_PathingGrid>();
	}
};
static_assert(alignof(UEnvQueryGenerator_PathingGrid) == 0x000008, "Wrong alignment on UEnvQueryGenerator_PathingGrid");
static_assert(sizeof(UEnvQueryGenerator_PathingGrid) == 0x000170, "Wrong size on UEnvQueryGenerator_PathingGrid");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, PathToItem) == 0x0000F8, "Member 'UEnvQueryGenerator_PathingGrid::PathToItem' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, NavigationFilter) == 0x000130, "Member 'UEnvQueryGenerator_PathingGrid::NavigationFilter' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, ScanRangeMultiplier) == 0x000138, "Member 'UEnvQueryGenerator_PathingGrid::ScanRangeMultiplier' has a wrong offset!");

// Class AIModule.EnvQueryInstanceBlueprintWrapper
// 0x0050 (0x0078 - 0x0028)
class UEnvQueryInstanceBlueprintWrapper final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         QueryID;                                           // 0x0030(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_34[0x24];                                      // 0x0034(0x0024)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryItemType>          ItemType;                                          // 0x0058(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         OptionIndex;                                       // 0x0060(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_64[0x4];                                       // 0x0064(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)> OnQueryFinishedEvent; // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)

public:
	void SetNamedParam(class FName ParamName, float Value);

	float GetItemScore(int32 ItemIndex) const;
	bool GetQueryResultsAsActors(TArray<class AActor*>* ResultActors) const;
	bool GetQueryResultsAsLocations(TArray<struct FVector>* ResultLocations) const;
	TArray<class AActor*> GetResultsAsActors() const;
	TArray<struct FVector> GetResultsAsLocations() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryInstanceBlueprintWrapper">();
	}
	static class UEnvQueryInstanceBlueprintWrapper* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryInstanceBlueprintWrapper>();
	}
};
static_assert(alignof(UEnvQueryInstanceBlueprintWrapper) == 0x000008, "Wrong alignment on UEnvQueryInstanceBlueprintWrapper");
static_assert(sizeof(UEnvQueryInstanceBlueprintWrapper) == 0x000078, "Wrong size on UEnvQueryInstanceBlueprintWrapper");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, QueryID) == 0x000030, "Member 'UEnvQueryInstanceBlueprintWrapper::QueryID' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, ItemType) == 0x000058, "Member 'UEnvQueryInstanceBlueprintWrapper::ItemType' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, OptionIndex) == 0x000060, "Member 'UEnvQueryInstanceBlueprintWrapper::OptionIndex' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, OnQueryFinishedEvent) == 0x000068, "Member 'UEnvQueryInstanceBlueprintWrapper::OnQueryFinishedEvent' has a wrong offset!");

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

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

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

// Class AIModule.EnvQueryOption
// 0x0018 (0x0040 - 0x0028)
class UEnvQueryOption final : public UObject
{
public:
	class UEnvQueryGenerator*                     Generator;                                         // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UEnvQueryTest*>                  Tests;                                             // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryOption">();
	}
	static class UEnvQueryOption* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryOption>();
	}
};
static_assert(alignof(UEnvQueryOption) == 0x000008, "Wrong alignment on UEnvQueryOption");
static_assert(sizeof(UEnvQueryOption) == 0x000040, "Wrong size on UEnvQueryOption");
static_assert(offsetof(UEnvQueryOption, Generator) == 0x000028, "Member 'UEnvQueryOption::Generator' has a wrong offset!");
static_assert(offsetof(UEnvQueryOption, Tests) == 0x000030, "Member 'UEnvQueryOption::Tests' has a wrong offset!");

// Class AIModule.EnvQueryTest_Distance
// 0x0010 (0x0208 - 0x01F8)
class UEnvQueryTest_Distance final : public UEnvQueryTest
{
public:
	EEnvTestDistance                              TestMode;                                          // 0x01F8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F9[0x7];                                      // 0x01F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UEnvQueryContext>           DistanceTo;                                        // 0x0200(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Distance">();
	}
	static class UEnvQueryTest_Distance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Distance>();
	}
};
static_assert(alignof(UEnvQueryTest_Distance) == 0x000008, "Wrong alignment on UEnvQueryTest_Distance");
static_assert(sizeof(UEnvQueryTest_Distance) == 0x000208, "Wrong size on UEnvQueryTest_Distance");
static_assert(offsetof(UEnvQueryTest_Distance, TestMode) == 0x0001F8, "Member 'UEnvQueryTest_Distance::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Distance, DistanceTo) == 0x000200, "Member 'UEnvQueryTest_Distance::DistanceTo' has a wrong offset!");

// Class AIModule.EnvQueryTest_Dot
// 0x0048 (0x0240 - 0x01F8)
class UEnvQueryTest_Dot final : public UEnvQueryTest
{
public:
	struct FEnvDirection                          lineA;                                             // 0x01F8(0x0020)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FEnvDirection                          lineB;                                             // 0x0218(0x0020)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)
	EEnvTestDot                                   TestMode;                                          // 0x0238(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bAbsoluteValue;                                    // 0x0239(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_23A[0x6];                                      // 0x023A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Dot">();
	}
	static class UEnvQueryTest_Dot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Dot>();
	}
};
static_assert(alignof(UEnvQueryTest_Dot) == 0x000008, "Wrong alignment on UEnvQueryTest_Dot");
static_assert(sizeof(UEnvQueryTest_Dot) == 0x000240, "Wrong size on UEnvQueryTest_Dot");
static_assert(offsetof(UEnvQueryTest_Dot, lineA) == 0x0001F8, "Member 'UEnvQueryTest_Dot::lineA' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, lineB) == 0x000218, "Member 'UEnvQueryTest_Dot::lineB' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, TestMode) == 0x000238, "Member 'UEnvQueryTest_Dot::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, bAbsoluteValue) == 0x000239, "Member 'UEnvQueryTest_Dot::bAbsoluteValue' has a wrong offset!");

// Class AIModule.EnvQueryTest_GameplayTags
// 0x0070 (0x0268 - 0x01F8)
class UEnvQueryTest_GameplayTags final : public UEnvQueryTest
{
public:
	struct FGameplayTagQuery                      TagQueryToMatch;                                   // 0x01F8(0x0048)(Edit, Protected, NativeAccessSpecifierProtected)
	bool                                          bUpdatedToUseQuery;                                // 0x0240(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EGameplayContainerMatchType                   TagsToMatch;                                       // 0x0241(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_242[0x6];                                      // 0x0242(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  GameplayTags;                                      // 0x0248(0x0020)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_GameplayTags">();
	}
	static class UEnvQueryTest_GameplayTags* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_GameplayTags>();
	}
};
static_assert(alignof(UEnvQueryTest_GameplayTags) == 0x000008, "Wrong alignment on UEnvQueryTest_GameplayTags");
static_assert(sizeof(UEnvQueryTest_GameplayTags) == 0x000268, "Wrong size on UEnvQueryTest_GameplayTags");
static_assert(offsetof(UEnvQueryTest_GameplayTags, TagQueryToMatch) == 0x0001F8, "Member 'UEnvQueryTest_GameplayTags::TagQueryToMatch' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, bUpdatedToUseQuery) == 0x000240, "Member 'UEnvQueryTest_GameplayTags::bUpdatedToUseQuery' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, TagsToMatch) == 0x000241, "Member 'UEnvQueryTest_GameplayTags::TagsToMatch' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, GameplayTags) == 0x000248, "Member 'UEnvQueryTest_GameplayTags::GameplayTags' has a wrong offset!");

// Class AIModule.EnvQueryTest_Overlap
// 0x0020 (0x0218 - 0x01F8)
class UEnvQueryTest_Overlap final : public UEnvQueryTest
{
public:
	struct FEnvOverlapData                        OverlapData;                                       // 0x01F8(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Overlap">();
	}
	static class UEnvQueryTest_Overlap* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Overlap>();
	}
};
static_assert(alignof(UEnvQueryTest_Overlap) == 0x000008, "Wrong alignment on UEnvQueryTest_Overlap");
static_assert(sizeof(UEnvQueryTest_Overlap) == 0x000218, "Wrong size on UEnvQueryTest_Overlap");
static_assert(offsetof(UEnvQueryTest_Overlap, OverlapData) == 0x0001F8, "Member 'UEnvQueryTest_Overlap::OverlapData' has a wrong offset!");

// Class AIModule.EnvQueryTest_PathfindingBatch
// 0x0038 (0x02B8 - 0x0280)
class UEnvQueryTest_PathfindingBatch final : public UEnvQueryTest_Pathfinding
{
public:
	struct FAIDataProviderFloatValue              ScanRangeMultiplier;                               // 0x0280(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_PathfindingBatch">();
	}
	static class UEnvQueryTest_PathfindingBatch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_PathfindingBatch>();
	}
};
static_assert(alignof(UEnvQueryTest_PathfindingBatch) == 0x000008, "Wrong alignment on UEnvQueryTest_PathfindingBatch");
static_assert(sizeof(UEnvQueryTest_PathfindingBatch) == 0x0002B8, "Wrong size on UEnvQueryTest_PathfindingBatch");
static_assert(offsetof(UEnvQueryTest_PathfindingBatch, ScanRangeMultiplier) == 0x000280, "Member 'UEnvQueryTest_PathfindingBatch::ScanRangeMultiplier' has a wrong offset!");

// Class AIModule.EnvQueryTest_Random
// 0x0000 (0x01F8 - 0x01F8)
class UEnvQueryTest_Random final : public UEnvQueryTest
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Random">();
	}
	static class UEnvQueryTest_Random* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Random>();
	}
};
static_assert(alignof(UEnvQueryTest_Random) == 0x000008, "Wrong alignment on UEnvQueryTest_Random");
static_assert(sizeof(UEnvQueryTest_Random) == 0x0001F8, "Wrong size on UEnvQueryTest_Random");

// Class AIModule.EnvQueryTest_Trace
// 0x00E0 (0x02D8 - 0x01F8)
class UEnvQueryTest_Trace final : public UEnvQueryTest
{
public:
	struct FEnvTraceData                          TraceData;                                         // 0x01F8(0x0030)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FAIDataProviderBoolValue               TraceFromContext;                                  // 0x0228(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ItemHeightOffset;                                  // 0x0260(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FAIDataProviderFloatValue              ContextHeightOffset;                               // 0x0298(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
	TSubclassOf<class UEnvQueryContext>           Context;                                           // 0x02D0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Trace">();
	}
	static class UEnvQueryTest_Trace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Trace>();
	}
};
static_assert(alignof(UEnvQueryTest_Trace) == 0x000008, "Wrong alignment on UEnvQueryTest_Trace");
static_assert(sizeof(UEnvQueryTest_Trace) == 0x0002D8, "Wrong size on UEnvQueryTest_Trace");
static_assert(offsetof(UEnvQueryTest_Trace, TraceData) == 0x0001F8, "Member 'UEnvQueryTest_Trace::TraceData' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, TraceFromContext) == 0x000228, "Member 'UEnvQueryTest_Trace::TraceFromContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, ItemHeightOffset) == 0x000260, "Member 'UEnvQueryTest_Trace::ItemHeightOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, ContextHeightOffset) == 0x000298, "Member 'UEnvQueryTest_Trace::ContextHeightOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, Context) == 0x0002D0, "Member 'UEnvQueryTest_Trace::Context' has a wrong offset!");

// Class AIModule.EnvQueryTest_Volume
// 0x0018 (0x0210 - 0x01F8)
class UEnvQueryTest_Volume final : public UEnvQueryTest
{
public:
	TSubclassOf<class UEnvQueryContext>           VolumeContext;                                     // 0x01F8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSubclassOf<class AVolume>                    VolumeClass;                                       // 0x0200(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bDoComplexVolumeTest : 1;                          // 0x0208(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_209[0x7];                                      // 0x0209(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnvQueryTest_Volume">();
	}
	static class UEnvQueryTest_Volume* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnvQueryTest_Volume>();
	}
};
static_assert(alignof(UEnvQueryTest_Volume) == 0x000008, "Wrong alignment on UEnvQueryTest_Volume");
static_assert(sizeof(UEnvQueryTest_Volume) == 0x000210, "Wrong size on UEnvQueryTest_Volume");
static_assert(offsetof(UEnvQueryTest_Volume, VolumeContext) == 0x0001F8, "Member 'UEnvQueryTest_Volume::VolumeContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Volume, VolumeClass) == 0x000200, "Member 'UEnvQueryTest_Volume::VolumeClass' has a wrong offset!");

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

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

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

// Class AIModule.EQSRenderingComponent
// 0x0040 (0x0490 - 0x0450)
class UEQSRenderingComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_450[0x40];                                     // 0x0450(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.EQSTestingPawn
// 0x0090 (0x0550 - 0x04C0)
class AEQSTestingPawn final : public ACharacter
{
public:
	uint8                                         Pad_4B8[0x8];                                      // 0x04B8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UEnvQuery*                              QueryTemplate;                                     // 0x04C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FEnvNamedValue>                 QueryParams;                                       // 0x04C8(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
	TArray<struct FAIDynamicParam>                QueryConfig;                                       // 0x04D8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         TimeLimitPerStep;                                  // 0x04E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         StepToDebugDraw;                                   // 0x04EC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEnvQueryHightlightMode                       HighlightMode;                                     // 0x04F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4F1[0x3];                                      // 0x04F1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDrawLabels : 1;                                   // 0x04F4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawFailedItems : 1;                              // 0x04F4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReRunQueryOnlyOnFinishedMove : 1;                 // 0x04F4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldBeVisibleInGame : 1;                        // 0x04F4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTickDuringGame : 1;                               // 0x04F4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4F5[0x3];                                      // 0x04F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EEnvQueryRunMode                              QueryingMode;                                      // 0x04F8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4F9[0x7];                                      // 0x04F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNavAgentProperties                    NavAgentProperties;                                // 0x0500(0x0030)(Edit, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_530[0x20];                                     // 0x0530(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EQSTestingPawn">();
	}
	static class AEQSTestingPawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<AEQSTestingPawn>();
	}
};
static_assert(alignof(AEQSTestingPawn) == 0x000010, "Wrong alignment on AEQSTestingPawn");
static_assert(sizeof(AEQSTestingPawn) == 0x000550, "Wrong size on AEQSTestingPawn");
static_assert(offsetof(AEQSTestingPawn, QueryTemplate) == 0x0004C0, "Member 'AEQSTestingPawn::QueryTemplate' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryParams) == 0x0004C8, "Member 'AEQSTestingPawn::QueryParams' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryConfig) == 0x0004D8, "Member 'AEQSTestingPawn::QueryConfig' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, TimeLimitPerStep) == 0x0004E8, "Member 'AEQSTestingPawn::TimeLimitPerStep' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, StepToDebugDraw) == 0x0004EC, "Member 'AEQSTestingPawn::StepToDebugDraw' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, HighlightMode) == 0x0004F0, "Member 'AEQSTestingPawn::HighlightMode' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryingMode) == 0x0004F8, "Member 'AEQSTestingPawn::QueryingMode' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, NavAgentProperties) == 0x000500, "Member 'AEQSTestingPawn::NavAgentProperties' has a wrong offset!");

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

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

// Class AIModule.GridPathAIController
// 0x0000 (0x0328 - 0x0328)
class AGridPathAIController final : public AAIController
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GridPathAIController">();
	}
	static class AGridPathAIController* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGridPathAIController>();
	}
};
static_assert(alignof(AGridPathAIController) == 0x000008, "Wrong alignment on AGridPathAIController");
static_assert(sizeof(AGridPathAIController) == 0x000328, "Wrong size on AGridPathAIController");

// Class AIModule.GridPathFollowingComponent
// 0x0030 (0x0280 - 0x0250)
class UGridPathFollowingComponent final : public UPathFollowingComponent
{
public:
	class UNavLocalGridManager*                   GridManager;                                       // 0x0250(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_258[0x28];                                     // 0x0258(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GridPathFollowingComponent">();
	}
	static class UGridPathFollowingComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGridPathFollowingComponent>();
	}
};
static_assert(alignof(UGridPathFollowingComponent) == 0x000008, "Wrong alignment on UGridPathFollowingComponent");
static_assert(sizeof(UGridPathFollowingComponent) == 0x000280, "Wrong size on UGridPathFollowingComponent");
static_assert(offsetof(UGridPathFollowingComponent, GridManager) == 0x000250, "Member 'UGridPathFollowingComponent::GridManager' has a wrong offset!");

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

// Class AIModule.NavLinkProxy
// 0x0050 (0x0270 - 0x0220)
class ANavLinkProxy final : public AActor
{
public:
	uint8                                         Pad_220[0x10];                                     // 0x0220(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FNavigationLink>                PointLinks;                                        // 0x0230(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FNavigationSegmentLink>         SegmentLinks;                                      // 0x0240(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class UNavLinkCustomComponent*                SmartLinkComp;                                     // 0x0250(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bSmartLinkIsRelevant;                              // 0x0258(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_259[0x7];                                      // 0x0259(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class AActor* MovingActor, const struct FVector& DestinationPoint)> OnSmartLinkReached; // 0x0260(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)

public:
	void ReceiveSmartLinkReached(class AActor* Agent, const struct FVector& Destination);
	void ResumePathFollowing(class AActor* Agent);
	void SetSmartLinkEnabled(bool bEnabled);

	bool HasMovingAgents() const;
	bool IsSmartLinkEnabled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkProxy">();
	}
	static class ANavLinkProxy* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavLinkProxy>();
	}
};
static_assert(alignof(ANavLinkProxy) == 0x000008, "Wrong alignment on ANavLinkProxy");
static_assert(sizeof(ANavLinkProxy) == 0x000270, "Wrong size on ANavLinkProxy");
static_assert(offsetof(ANavLinkProxy, PointLinks) == 0x000230, "Member 'ANavLinkProxy::PointLinks' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, SegmentLinks) == 0x000240, "Member 'ANavLinkProxy::SegmentLinks' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, SmartLinkComp) == 0x000250, "Member 'ANavLinkProxy::SmartLinkComp' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, bSmartLinkIsRelevant) == 0x000258, "Member 'ANavLinkProxy::bSmartLinkIsRelevant' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, OnSmartLinkReached) == 0x000260, "Member 'ANavLinkProxy::OnSmartLinkReached' has a wrong offset!");

// Class AIModule.NavLocalGridManager
// 0x0030 (0x0058 - 0x0028)
class UNavLocalGridManager final : public UObject
{
public:
	uint8                                         Pad_28[0x30];                                      // 0x0028(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static int32 AddLocalNavigationGridForBox(class UObject* WorldContextObject, const struct FVector& Location, const struct FVector& Extent, const struct FRotator& Rotation, const int32 Radius2D, const float Height, bool bRebuildGrids);
	static int32 AddLocalNavigationGridForCapsule(class UObject* WorldContextObject, const struct FVector& Location, float CapsuleRadius, float CapsuleHalfHeight, const int32 Radius2D, const float Height, bool bRebuildGrids);
	static int32 AddLocalNavigationGridForPoint(class UObject* WorldContextObject, const struct FVector& Location, const int32 Radius2D, const float Height, bool bRebuildGrids);
	static int32 AddLocalNavigationGridForPoints(class UObject* WorldContextObject, const TArray<struct FVector>& Locations, const int32 Radius2D, const float Height, bool bRebuildGrids);
	static bool FindLocalNavigationGridPath(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TArray<struct FVector>* PathPoints);
	static void RemoveLocalNavigationGrid(class UObject* WorldContextObject, int32 GridId, bool bRebuildGrids);
	static bool SetLocalNavigationGridDensity(class UObject* WorldContextObject, float CellSize);

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

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

// Class AIModule.PawnAction_Move
// 0x0050 (0x00E0 - 0x0090)
class UPawnAction_Move final : public UPawnAction
{
public:
	class AActor*                                 GoalActor;                                         // 0x0090(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                GoalLocation;                                      // 0x0098(0x000C)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AcceptableRadius;                                  // 0x00A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UNavigationQueryFilter>     FilterClass;                                       // 0x00A8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bAllowStrafe : 1;                                  // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bFinishOnOverlap : 1;                              // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bUsePathfinding : 1;                               // 0x00B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAllowPartialPath : 1;                             // 0x00B0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bProjectGoalToNavigation : 1;                      // 0x00B0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bUpdatePathToGoal : 1;                             // 0x00B0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAbortChildActionOnPathChange : 1;                 // 0x00B0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_B1[0x2F];                                      // 0x00B1(0x002F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnAction_Move">();
	}
	static class UPawnAction_Move* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnAction_Move>();
	}
};
static_assert(alignof(UPawnAction_Move) == 0x000008, "Wrong alignment on UPawnAction_Move");
static_assert(sizeof(UPawnAction_Move) == 0x0000E0, "Wrong size on UPawnAction_Move");
static_assert(offsetof(UPawnAction_Move, GoalActor) == 0x000090, "Member 'UPawnAction_Move::GoalActor' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, GoalLocation) == 0x000098, "Member 'UPawnAction_Move::GoalLocation' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, AcceptableRadius) == 0x0000A4, "Member 'UPawnAction_Move::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, FilterClass) == 0x0000A8, "Member 'UPawnAction_Move::FilterClass' has a wrong offset!");

// Class AIModule.PawnAction_Sequence
// 0x0028 (0x00B8 - 0x0090)
class UPawnAction_Sequence final : public UPawnAction
{
public:
	TArray<class UPawnAction*>                    ActionSequence;                                    // 0x0090(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	EPawnActionFailHandling                       ChildFailureHandlingMode;                          // 0x00A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A1[0x7];                                       // 0x00A1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPawnAction*                            RecentActionCopy;                                  // 0x00A8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B0[0x8];                                       // 0x00B0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnAction_Sequence">();
	}
	static class UPawnAction_Sequence* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnAction_Sequence>();
	}
};
static_assert(alignof(UPawnAction_Sequence) == 0x000008, "Wrong alignment on UPawnAction_Sequence");
static_assert(sizeof(UPawnAction_Sequence) == 0x0000B8, "Wrong size on UPawnAction_Sequence");
static_assert(offsetof(UPawnAction_Sequence, ActionSequence) == 0x000090, "Member 'UPawnAction_Sequence::ActionSequence' has a wrong offset!");
static_assert(offsetof(UPawnAction_Sequence, ChildFailureHandlingMode) == 0x0000A0, "Member 'UPawnAction_Sequence::ChildFailureHandlingMode' has a wrong offset!");
static_assert(offsetof(UPawnAction_Sequence, RecentActionCopy) == 0x0000A8, "Member 'UPawnAction_Sequence::RecentActionCopy' has a wrong offset!");

// Class AIModule.PawnAction_Wait
// 0x0010 (0x00A0 - 0x0090)
class UPawnAction_Wait final : public UPawnAction
{
public:
	float                                         TimeToWait;                                        // 0x0090(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_94[0xC];                                       // 0x0094(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class AIModule.PawnActionsComponent
// 0x0038 (0x00E8 - 0x00B0)
class UPawnActionsComponent final : public UActorComponent
{
public:
	class APawn*                                  ControlledPawn;                                    // 0x00B0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FPawnActionStack>               ActionStacks;                                      // 0x00B8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FPawnActionEvent>               ActionEvents;                                      // 0x00C8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	class UPawnAction*                            CurrentAction;                                     // 0x00D8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E0[0x8];                                       // 0x00E0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static bool K2_PerformAction(class APawn* Pawn, class UPawnAction* Action, EAIRequestPriority Priority);

	EPawnActionAbortState K2_AbortAction(class UPawnAction* ActionToAbort);
	EPawnActionAbortState K2_ForceAbortAction(class UPawnAction* ActionToAbort);
	bool K2_PushAction(class UPawnAction* NewAction, EAIRequestPriority Priority, class UObject* Instigator);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnActionsComponent">();
	}
	static class UPawnActionsComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnActionsComponent>();
	}
};
static_assert(alignof(UPawnActionsComponent) == 0x000008, "Wrong alignment on UPawnActionsComponent");
static_assert(sizeof(UPawnActionsComponent) == 0x0000E8, "Wrong size on UPawnActionsComponent");
static_assert(offsetof(UPawnActionsComponent, ControlledPawn) == 0x0000B0, "Member 'UPawnActionsComponent::ControlledPawn' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, ActionStacks) == 0x0000B8, "Member 'UPawnActionsComponent::ActionStacks' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, ActionEvents) == 0x0000C8, "Member 'UPawnActionsComponent::ActionEvents' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, CurrentAction) == 0x0000D8, "Member 'UPawnActionsComponent::CurrentAction' has a wrong offset!");

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

}

