#pragma once

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

// Package: PL_Core

#include "Basic.hpp"

#include "EnhancedInput_classes.hpp"
#include "PL_Core_structs.hpp"
#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "GameplayTags_structs.hpp"
#include "UMG_classes.hpp"
#include "DeveloperSettings_classes.hpp"
#include "LevelSequence_classes.hpp"


namespace SDK
{

// Class PL_Core.PL_ActorWithControlOverCanBeBaseForCharacter
// 0x0008 (0x0328 - 0x0320)
class APL_ActorWithControlOverCanBeBaseForCharacter final : public AActor
{
public:
	bool                                          bCanBeBaseForCharacter;                            // 0x0320(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_321[0x7];                                      // 0x0321(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ActorWithControlOverCanBeBaseForCharacter")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ActorWithControlOverCanBeBaseForCharacter")
	}
	static class APL_ActorWithControlOverCanBeBaseForCharacter* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_ActorWithControlOverCanBeBaseForCharacter>();
	}
};
DUMPER7_ASSERTS_APL_ActorWithControlOverCanBeBaseForCharacter;

// Class PL_Core.PL_AnimUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_AnimUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UAnimInstance* FindAnimInstance(const class AActor* Owner, const class FName& SkeletalMeshName);
	static bool GetSectionStartAndEndTime(const class UAnimMontage* Montage, const class FName& SectionName, float* OutStartTime, float* OutEndTime);
	static float GetTimeUntilNotification(class UAnimSequenceBase* AnimSequenceBase, const class FName& NotificationName);
	static float GetTimeUntilNotificationFromSection(class UAnimMontage* AnimSequenceBase, const class FName& SectionName, const class FName& NotificationName);
	static void SetPosition(class UAnimInstance* AnimInstance, class UAnimMontage* Montage, float Position);
	static void StopMontageImmediate(class UAnimInstance* AnimInstance, class UAnimMontage* Montage);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_AnimUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_AnimUtils")
	}
	static class UPL_AnimUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_AnimUtils>();
	}
};
DUMPER7_ASSERTS_UPL_AnimUtils;

// Class PL_Core.PL_AssertUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_AssertUtils final : public UBlueprintFunctionLibrary
{
public:
	static EPL_EnsureResult Ensure(const bool& bCondition, const class FString& Message, bool bShouldAlwaysBreak);
	static EPL_EnsureIsValidResult EnsureIsValid(const class UObject* Object, const class FString& Message, bool bShouldAlwaysBreak);
	static void EnsureNoEntry(const class FString& Message, bool bShouldAlwaysBreak);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_AssertUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_AssertUtils")
	}
	static class UPL_AssertUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_AssertUtils>();
	}
};
DUMPER7_ASSERTS_UPL_AssertUtils;

// Class PL_Core.PL_AssetUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_AssetUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_AssetUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_AssetUtils")
	}
	static class UPL_AssetUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_AssetUtils>();
	}
};
DUMPER7_ASSERTS_UPL_AssetUtils;

// Class PL_Core.PL_BackendLogger
// 0x0000 (0x0028 - 0x0028)
class UPL_BackendLogger final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BackendLogger")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BackendLogger")
	}
	static class UPL_BackendLogger* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BackendLogger>();
	}
};
DUMPER7_ASSERTS_UPL_BackendLogger;

// Class PL_Core.PL_BackendLoggingService
// 0x0000 (0x0028 - 0x0028)
class UPL_BackendLoggingService final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BackendLoggingService")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BackendLoggingService")
	}
	static class UPL_BackendLoggingService* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BackendLoggingService>();
	}
};
DUMPER7_ASSERTS_UPL_BackendLoggingService;

// Class PL_Core.PL_CharacterBaseListenerUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_CharacterBaseListenerUtils final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CharacterBaseListenerUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CharacterBaseListenerUtils")
	}
	static class UPL_CharacterBaseListenerUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CharacterBaseListenerUtils>();
	}
};
DUMPER7_ASSERTS_UPL_CharacterBaseListenerUtils;

// Class PL_Core.PL_CharacterBaseListenerInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_CharacterBaseListenerInterface final
{
public:
	void ComponentStartBeingBaseForCharacter(class ACharacter* Character, class UPrimitiveComponent* Component, bool bBaseActorChanged);
	void ComponentStopBeingBaseForCharacter(class ACharacter* Character, class UPrimitiveComponent* Component, bool bBaseActorChanged);
	void StartBeingBaseForCharacter(class ACharacter* Character);
	void StopBeingBaseForCharacter(class ACharacter* Character);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CharacterBaseListenerInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CharacterBaseListenerInterface")
	}
	static class IPL_CharacterBaseListenerInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_CharacterBaseListenerInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_CharacterBaseListenerInterface;

// Class PL_Core.PL_CharacterMovementConnectionInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_CharacterMovementConnectionInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CharacterMovementConnectionInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CharacterMovementConnectionInterface")
	}
	static class IPL_CharacterMovementConnectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_CharacterMovementConnectionInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_CharacterMovementConnectionInterface;

// Class PL_Core.PL_ActorConnectionListenerInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_ActorConnectionListenerInterface final
{
public:
	void CharacterAddConnection(class UPL_ConnectedComponentMovement* Connection);
	void CharacterRemoveConnection(class UPL_ConnectedComponentMovement* Connection);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ActorConnectionListenerInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ActorConnectionListenerInterface")
	}
	static class IPL_ActorConnectionListenerInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_ActorConnectionListenerInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_ActorConnectionListenerInterface;

// Class PL_Core.PL_ClassUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ClassUtils final : public UBlueprintFunctionLibrary
{
public:
	static class FText Conv_ClassToText(const class UClass* Class_0);
	static class FText Conv_SoftClassToText(const TSoftClassPtr<class UClass>& Class_0);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ClassUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ClassUtils")
	}
	static class UPL_ClassUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ClassUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ClassUtils;

// Class PL_Core.PL_ComponentUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ComponentUtils final : public UBlueprintFunctionLibrary
{
public:
	static void AddAllComponentsWithInterface(TArray<class UObject*>* OutObjectsWithInterface, class AActor* Actor, TSubclassOf<class IInterface> InterfaceClass);
	static class UActorComponent* CreateActorComponentAtRunTime(class AActor* TargetActor, TSubclassOf<class UActorComponent> ComponentClass, bool bAllowAnyoneToDestroy, class FName Name_0);
	static class UActorComponent* FindComponentInChildActors(const TSubclassOf<class UActorComponent> ComponentClass, class AActor* OwningActor, bool bSearchDescendantChildActors);
	static class UActorComponent* FindOrCreateComponentOnGameState(TSubclassOf<class UActorComponent> ComponentClass, class UObject* WorldContextObject);
	static TArray<class UActorComponent*> GetAllComponentsWithInterface(class AActor* Actor, TSubclassOf<class IInterface> InterfaceClass);
	static class UActorComponent* GetComponentFromComponentReference(const struct FComponentReference& ComponentReference, class UObject* ContextObject);
	static class AController* GetController(class UActorComponent* ActorComponent);
	static class UActorComponent* GetFirstComponentWithInterface(class AActor* Actor, TSubclassOf<class IInterface> InterfaceClass);
	static bool HasSocketName(const class UMeshComponent* Mesh, const class FName& SocketName);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ComponentUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ComponentUtils")
	}
	static class UPL_ComponentUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ComponentUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ComponentUtils;

// Class PL_Core.PL_ConnectedComponentMovement
// 0x0168 (0x0190 - 0x0028)
class alignas(0x10) UPL_ConnectedComponentMovement final : public UObject
{
public:
	TMulticastInlineDelegate<void(const struct FVector& FailedDeltaMove, const struct FVector& StartLocation, const struct FHitResult& MoveWithConnectedComponentHit)> OnUnableToFollowConnectedComponent; // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FVector& ActuallyMovedDelta, const struct FTransform& NewConnectedComponentTransform)> OnMovedByConnectedComponent; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0x139];                                     // 0x0048(0x0139)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bCanCountAsBase;                                   // 0x0181(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldDisconnectOnNoCollision;                    // 0x0182(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldApplyRotationChangeToController;            // 0x0183(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldApplyWhileHavingBase;                       // 0x0184(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_185[0xB];                                      // 0x0185(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ConnectedComponentMovement")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ConnectedComponentMovement")
	}
	static class UPL_ConnectedComponentMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ConnectedComponentMovement>();
	}
};
DUMPER7_ASSERTS_UPL_ConnectedComponentMovement;

// Class PL_Core.PL_ConnectedMovementUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ConnectedMovementUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UPL_ConnectedComponentMovement* Connect(class ACharacter* Character, class UPrimitiveComponent* ComponentToConnect, TSubclassOf<class UPL_ConnectedComponentMovement> ConnectionClass);
	static void Disconnect(class ACharacter* Character, class UPL_ConnectedComponentMovement* Connection);
	static bool IsConnectedAsBase(class ACharacter* Character, class AActor* PotentialBase);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ConnectedMovementUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ConnectedMovementUtils")
	}
	static class UPL_ConnectedMovementUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ConnectedMovementUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ConnectedMovementUtils;

// Class PL_Core.PL_CurveUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_CurveUtils final : public UBlueprintFunctionLibrary
{
public:
	static float GetRuntimeFloatCurveValue(const struct FRuntimeFloatCurve& Target, float InTime);
	static struct FVector GetRuntimeVectorCurveValue(const struct FRuntimeVectorCurve& Target, float InTime);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CurveUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CurveUtils")
	}
	static class UPL_CurveUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CurveUtils>();
	}
};
DUMPER7_ASSERTS_UPL_CurveUtils;

// Class PL_Core.PL_DebugDrawUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_DebugDrawUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DebugDrawUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DebugDrawUtils")
	}
	static class UPL_DebugDrawUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DebugDrawUtils>();
	}
};
DUMPER7_ASSERTS_UPL_DebugDrawUtils;

// Class PL_Core.PL_DecalUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_DecalUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UDecalComponent* SpawnDecalAtLocation(const class UObject* WorldContextObject, const struct FPL_DecalSettings& DecalSettings, const struct FVector& Location, const struct FRotator& Rotation);
	static class UDecalComponent* SpawnDecalAttached(const struct FPL_DecalSettings& DecalSettings, class USceneComponent* AttachToComponent, const class FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, const EAttachLocation LocationType);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DecalUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DecalUtils")
	}
	static class UPL_DecalUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DecalUtils>();
	}
};
DUMPER7_ASSERTS_UPL_DecalUtils;

// Class PL_Core.PL_Delay
// 0x0060 (0x0090 - 0x0030)
class UPL_Delay final : public UBlueprintAsyncActionBase
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DurationSeconds;                                   // 0x0040(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnCompleted;                                       // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
	TMulticastInlineDelegate<void()>              OnCancel;                                          // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
	bool                                          bShouldReactToReset;                               // 0x0068(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorld*                                 World;                                             // 0x0070(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 ContextActor;                                      // 0x0078(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_80[0x10];                                      // 0x0080(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UPL_Delay* PL_Delay(class UObject* WorldContextObject, float Seconds, bool bShouldReactToReset_0);

	void Cancel();
	void OnActorEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);
	void OnTimerComplete();

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_Delay")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_Delay")
	}
	static class UPL_Delay* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_Delay>();
	}
};
DUMPER7_ASSERTS_UPL_Delay;

// Class PL_Core.PL_EnumUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_EnumUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool K2_HasFlag(int32 MaskValueAsInt, uint8 EnumValueAsUnit8);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_EnumUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_EnumUtils")
	}
	static class UPL_EnumUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_EnumUtils>();
	}
};
DUMPER7_ASSERTS_UPL_EnumUtils;

// Class PL_Core.PL_ForwardCharacterBaseEventComponent
// 0x0008 (0x00C8 - 0x00C0)
class UPL_ForwardCharacterBaseEventComponent final : public UActorComponent
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ForwardCharacterBaseEventComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ForwardCharacterBaseEventComponent")
	}
	static class UPL_ForwardCharacterBaseEventComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ForwardCharacterBaseEventComponent>();
	}
};
DUMPER7_ASSERTS_UPL_ForwardCharacterBaseEventComponent;

// Class PL_Core.PL_GameInstance
// 0x0020 (0x01E8 - 0x01C8)
class UPL_GameInstance : public UGameInstance
{
public:
	TMulticastInlineDelegate<void(const class FString& MapName)> OnLoadMapComplete;                  // 0x01C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UWorld* OldWorld, class UWorld* NewWorld)> OnWorldChangedDelegate; // 0x01D8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GameInstance")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GameInstance")
	}
	static class UPL_GameInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GameInstance>();
	}
};
DUMPER7_ASSERTS_UPL_GameInstance;

// Class PL_Core.PL_GetTexture2DAsync
// 0x0090 (0x00C0 - 0x0030)
class UPL_GetTexture2DAsync final : public UBlueprintAsyncActionBase
{
public:
	TMulticastInlineDelegate<void(class UTexture2D* Texture)> OnLoadCompleted;                       // 0x0030(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FPL_LazyTexture2D                      LazyTexture;                                       // 0x0040(0x0068)(Transient, DuplicateTransient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_A8[0x18];                                      // 0x00A8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UPL_GetTexture2DAsync* GetTexture2DAsync(class UObject* WorldContextObject, const struct FPL_LazyTexture2D& LazyTexture_0);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GetTexture2DAsync")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GetTexture2DAsync")
	}
	static class UPL_GetTexture2DAsync* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GetTexture2DAsync>();
	}
};
DUMPER7_ASSERTS_UPL_GetTexture2DAsync;

// Class PL_Core.PL_GlobalBlackboardGameStateInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_GlobalBlackboardGameStateInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GlobalBlackboardGameStateInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GlobalBlackboardGameStateInterface")
	}
	static class IPL_GlobalBlackboardGameStateInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_GlobalBlackboardGameStateInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_GlobalBlackboardGameStateInterface;

// Class PL_Core.PL_ApplyImpulseToTargetUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ApplyImpulseToTargetUtils final : public UBlueprintFunctionLibrary
{
public:
	static void ApplyCameraForwardImpulseToTarget(const struct FPL_ForwardImpulseToApplyToTarget& ImpulseData, const class AActor* Source, class AActor* Target, const struct FVector& Direction);
	static void ApplyForwardImpulseToTarget(const struct FPL_ForwardImpulseToApplyToTarget& ImpulseData, const class AActor* Source, class AActor* Target, const struct FVector& Direction);
	static void ApplyImpulseToTarget(const struct FPL_ImpulseToApplyToTarget& ImpulseData, class AActor* Target, const struct FVector& Direction);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ApplyImpulseToTargetUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ApplyImpulseToTargetUtils")
	}
	static class UPL_ApplyImpulseToTargetUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ApplyImpulseToTargetUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ApplyImpulseToTargetUtils;

// Class PL_Core.PL_IndicatorSourceInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_IndicatorSourceInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_IndicatorSourceInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_IndicatorSourceInterface")
	}
	static class IPL_IndicatorSourceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_IndicatorSourceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_IndicatorSourceInterface;

// Class PL_Core.PL_IndicatorWidgetInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_IndicatorWidgetInterface final
{
public:
	void SetSource(class UObject* IndicatorSource);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_IndicatorWidgetInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_IndicatorWidgetInterface")
	}
	static class IPL_IndicatorWidgetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_IndicatorWidgetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_IndicatorWidgetInterface;

// Class PL_Core.PL_IndicatorWidgetSetup
// 0x0040 (0x0070 - 0x0030)
class UPL_IndicatorWidgetSetup final : public UDataAsset
{
public:
	TSubclassOf<class UUserWidget>                WidgetClass;                                       // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              WorldWidgetOffset;                                 // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              DrawSize;                                          // 0x0048(0x0010)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              Pivot;                                             // 0x0058(0x0010)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDrawAtDesiredSize;                                // 0x0068(0x0001)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bKeepOnScreen;                                     // 0x0069(0x0001)(Edit, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6A[0x6];                                       // 0x006A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_IndicatorWidgetSetup")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_IndicatorWidgetSetup")
	}
	static class UPL_IndicatorWidgetSetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_IndicatorWidgetSetup>();
	}
};
DUMPER7_ASSERTS_UPL_IndicatorWidgetSetup;

// Class PL_Core.PL_InputUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_InputUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_InputUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_InputUtils")
	}
	static class UPL_InputUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_InputUtils>();
	}
};
DUMPER7_ASSERTS_UPL_InputUtils;

// Class PL_Core.PL_InterpolationUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_InterpolationUtils final : public UBlueprintFunctionLibrary
{
public:
	static float SmoothMoveTowards(float& InOutVelocity, float CurrentValue, float Target, float MaxVelocity, float MaxAcceleration, float DeltaSeconds);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_InterpolationUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_InterpolationUtils")
	}
	static class UPL_InterpolationUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_InterpolationUtils>();
	}
};
DUMPER7_ASSERTS_UPL_InterpolationUtils;

// Class PL_Core.PL_LabeledIconWidget
// 0x0040 (0x0380 - 0x0340)
class UPL_LabeledIconWidget final : public UUserWidget
{
public:
	struct FLinearColor                           ColorNotValidated;                                 // 0x0340(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FLinearColor                           ColorValid;                                        // 0x0350(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FLinearColor                           ColorInvalid;                                      // 0x0360(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UTextBlock*                             Label;                                             // 0x0370(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UImage*                                 Image;                                             // 0x0378(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LabeledIconWidget")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LabeledIconWidget")
	}
	static class UPL_LabeledIconWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LabeledIconWidget>();
	}
};
DUMPER7_ASSERTS_UPL_LabeledIconWidget;

// Class PL_Core.PL_LazyTexture2DUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_LazyTexture2DUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UTexture2D* Get(const struct FPL_LazyTexture2D& LazyTexture);
	static void Release(struct FPL_LazyTexture2D& LazyTexture);
	static void Reset(struct FPL_LazyTexture2D& LazyTexture);
	static void Set(struct FPL_LazyTexture2D& LazyTexture, TSoftObjectPtr<class UTexture2D> Texture);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LazyTexture2DUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LazyTexture2DUtils")
	}
	static class UPL_LazyTexture2DUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LazyTexture2DUtils>();
	}
};
DUMPER7_ASSERTS_UPL_LazyTexture2DUtils;

// Class PL_Core.PL_MaterialUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_MaterialUtils final : public UBlueprintFunctionLibrary
{
public:
	static void SetLinearColorParameterValueOnAllMaterials(class UMeshComponent* MeshComponent, const class FName& ParameterName, const struct FLinearColor& ParameterValue);
	static void SetLinearColorParameterValueOnMaterial(class UMeshComponent* MeshComponent, const int32 MaterialIndex, const class FName& ParameterName, const struct FLinearColor& ParameterValue);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_MaterialUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_MaterialUtils")
	}
	static class UPL_MaterialUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_MaterialUtils>();
	}
};
DUMPER7_ASSERTS_UPL_MaterialUtils;

// Class PL_Core.PL_MathUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_MathUtils final : public UBlueprintFunctionLibrary
{
public:
	static TArray<struct FVector> DistributePointsOnHalfSphere(const struct FVector& Location, float Radius, int32 Num, const struct FVector& Direction);
	static TArray<struct FVector> DistributePointsOnHorizontalRing(const struct FVector& Location, float Radius, int32 Num);
	static TArray<struct FVector> DistributePointsOnRing(const struct FVector& Location, float Radius, int32 Num, const struct FVector& Direction);
	static TArray<struct FVector> DistributePointsOnSphere(const struct FVector& Location, float Radius, int32 Num, EPL_PointsOnSphereRestriction PointsOnSphereRestriction);
	static struct FQuat LimitRotation(const struct FQuat& Source, const struct FQuat& Target, double LimitRadians);
	static int32 Modulus(int32 Value, int32 Divisor);
	static double PointPlaneDistance(const struct FVector& Point, const struct FPlane& Plane);
	static struct FRotator RandomRotation(const struct FRotator& Range);
	static struct FVector2D SolveQuadraticFormula(double A, double B, double C);
	static double SolveQuadraticFormulaSide(double A, double B, double C, EPL_QuadraticSide WantedSide);
	static bool TryFindLineSphereIntersection(const struct FVector& LineOrigin, const struct FVector& LineDirection, const struct FVector& SphereLocation, double SphereRadius, struct FVector* OutIntersectLocation);
	static bool TryToDetermineInterceptLocation(const struct FVector& ShooterPosition, const float ProjectileSpeed, const struct FVector& TargetPosition, const struct FVector& TargetVelocity, struct FVector* OutInterceptLocation);
	static int32 WrapIndex(int32 Index_0, int32 ElementCount);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_MathUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_MathUtils")
	}
	static class UPL_MathUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_MathUtils>();
	}
};
DUMPER7_ASSERTS_UPL_MathUtils;

// Class PL_Core.PL_MessageLogUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_MessageLogUtils final : public UBlueprintFunctionLibrary
{
public:
	static void Error(const class FString& Message, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void ErrorWithAssetToken(const class FString& Message, const class FString& AssetPath, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void ErrorWithObjectToken(const class FString& Message, const class UObject* TokenObject, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static class FString GetLevelNameActorIsIn(const class AActor* Actor);
	static void Info(const class FString& Message, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void InfoWithAssetToken(const class FString& Message, const class FString& AssetPath, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void InfoWithObjectToken(const class FString& Message, const class UObject* TokenObject, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void NewPage(const class FText& Title, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void Warning(const class FString& Message, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void WarningWithAssetToken(const class FString& Message, const class FString& AssetPath, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);
	static void WarningWithObjectToken(const class FString& Message, const class UObject* TokenObject, const class FText& LabelOveride, EPL_MessageLogChannels LoggingChannel, const class FName& CustomChannelName);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_MessageLogUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_MessageLogUtils")
	}
	static class UPL_MessageLogUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_MessageLogUtils>();
	}
};
DUMPER7_ASSERTS_UPL_MessageLogUtils;

// Class PL_Core.PL_MontageSettingsObject
// 0x0020 (0x0048 - 0x0028)
class UPL_MontageSettingsObject final : public UObject
{
public:
	struct FPL_MontageSettings                    Value;                                             // 0x0028(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_MontageSettingsObject")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_MontageSettingsObject")
	}
	static class UPL_MontageSettingsObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_MontageSettingsObject>();
	}
};
DUMPER7_ASSERTS_UPL_MontageSettingsObject;

// Class PL_Core.PL_ObjectUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ObjectUtils final : public UBlueprintFunctionLibrary
{
public:
	static const class UObject* GetDefaultObject(const TSubclassOf<class UObject>& ObjectClass);
	static class UObject* GetFirstInterfaceImplementor(class UObject* Object, TSubclassOf<class IInterface> InterfaceClass);
	static class FString GetObjectLabelSafe(const class UObject* Object);
	static bool MarkPackageDirty(class UObject* Object);
	static bool ModifyObject(class UObject* Object, bool bAlwaysMarkDirty);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ObjectUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ObjectUtils")
	}
	static class UPL_ObjectUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ObjectUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ObjectUtils;

// Class PL_Core.PL_PauserChangeInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_PauserChangeInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PauserChangeInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PauserChangeInterface")
	}
	static class IPL_PauserChangeInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_PauserChangeInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_PauserChangeInterface;

// Class PL_Core.PL_PersistenceBehaviorProvider
// 0x0000 (0x0000 - 0x0000)
class IPL_PersistenceBehaviorProvider final
{
public:
	EPL_PersistenceBehavior GetPersistenceBehavior() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PersistenceBehaviorProvider")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PersistenceBehaviorProvider")
	}
	static class IPL_PersistenceBehaviorProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_PersistenceBehaviorProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
//DUMPER7_ASSERTS_IPL_PersistenceBehaviorProvider;

// Class PL_Core.PL_PlayerController
// 0x0040 (0x07F0 - 0x07B0)
class APL_PlayerController : public APlayerController
{
public:
	TMulticastInlineDelegate<void(class APawn* NewPawn)> OnPawnChanged;                              // 0x07B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(bool bEnabled)> OnSmartCameraEnabledChanged;                       // 0x07C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	bool                                          bIsCameraShakeEnabled;                             // 0x07D0(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsSmartCameraEnabled;                             // 0x07D1(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_7D2[0x6];                                      // 0x07D2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UInputComponent>            OverrideInputComponentClass;                       // 0x07D8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FPL_EnhancedInputMappingContextSettingData> DefaultMappingContexts;                // 0x07E0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PlayerController")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PlayerController")
	}
	static class APL_PlayerController* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_PlayerController>();
	}
};
DUMPER7_ASSERTS_APL_PlayerController;

// Class PL_Core.PL_PropertyUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_PropertyUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PropertyUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PropertyUtils")
	}
	static class UPL_PropertyUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_PropertyUtils>();
	}
};
DUMPER7_ASSERTS_UPL_PropertyUtils;

// Class PL_Core.PL_RootActorProvider
// 0x0000 (0x0000 - 0x0000)
class IPL_RootActorProvider final
{
public:
	class AActor* GetRootActor() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_RootActorProvider")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_RootActorProvider")
	}
	static class IPL_RootActorProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_RootActorProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_RootActorProvider;

// Class PL_Core.PL_StringUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_StringUtils final : public UBlueprintFunctionLibrary
{
public:
	static class FString BeautifyString(const class FString& InString, bool bIsBool);
	static class FString DurationToString(double DurationInSeconds, const class FString& Format);
	static class FString FloatToString(float Value, int32 Precision);
	static bool IsStringArrayEquals(const TArray<class FString>& StringA, const TArray<class FString>& StringB);
	static void RemoveWhiteSpaces(class FString* InOutString);
	static class FString VectorToString(const struct FVector& Value, int32 Precision, const class FString& Seperator);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StringUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StringUtils")
	}
	static class UPL_StringUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StringUtils>();
	}
};
DUMPER7_ASSERTS_UPL_StringUtils;

// Class PL_Core.PL_SubsystemUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_SubsystemUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SubsystemUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SubsystemUtils")
	}
	static class UPL_SubsystemUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_SubsystemUtils>();
	}
};
DUMPER7_ASSERTS_UPL_SubsystemUtils;

// Class PL_Core.PL_SweepColliderSourceInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_SweepColliderSourceInterface final
{
public:
	void CollectActiveSweepColliders(TArray<struct FPL_SweepCollider>& InOutActiveSweepColliders, const struct FPL_SweepCollidersSettingInternal& Setting) const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SweepColliderSourceInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SweepColliderSourceInterface")
	}
	static class IPL_SweepColliderSourceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_SweepColliderSourceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_SweepColliderSourceInterface;

// Class PL_Core.PL_SweepColliderUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_SweepColliderUtils final : public UBlueprintFunctionLibrary
{
public:
	static void AppendSweepCollidersFromPhysicsAsset(class UPrimitiveComponent* PhysicsSource, class UPhysicsAsset* PhysicsAsset, float ColliderInflation, TArray<struct FPL_SweepCollider>& InOutSweepColliders);
	static TArray<struct FPL_SweepCollider> CreateSweepCollidersFromPhysicsAsset(class UPrimitiveComponent* PhysicsSource, class UPhysicsAsset* PhysicsAsset, float ColliderInflation);
	static struct FPL_SweepCollider MakeSweepCollider(class UPrimitiveComponent* ColliderSource, float ColliderInflation);
	static struct FPL_SweepCollider MakeSweepColliderFromSocketAndShape(class UPrimitiveComponent* SocketSource, const class FName& SocketName, class UPrimitiveComponent* ColliderSource, float ColliderInflation);
	static void SetSweepCollidersFromPhysicsAsset(class UPrimitiveComponent* PhysicsSource, class UPhysicsAsset* PhysicsAsset, float ColliderInflation, TArray<struct FPL_SweepCollider>& InOutSweepColliders);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SweepColliderUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SweepColliderUtils")
	}
	static class UPL_SweepColliderUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_SweepColliderUtils>();
	}
};
DUMPER7_ASSERTS_UPL_SweepColliderUtils;

// Class PL_Core.PL_SystemUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_SystemUtils final : public UBlueprintFunctionLibrary
{
public:
	static struct FIntPoint GetSystemResolution();

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SystemUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SystemUtils")
	}
	static class UPL_SystemUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_SystemUtils>();
	}
};
DUMPER7_ASSERTS_UPL_SystemUtils;

// Class PL_Core.PL_Ticket
// 0x0018 (0x0040 - 0x0028)
class UPL_Ticket final : public UObject
{
public:
	class UObject*                                ContextObject;                                     // 0x0028(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FName                                   Context;                                           // 0x0030(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TWeakObjectPtr<class UPL_Ticketer>            Owner;                                             // 0x0038(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void Release();
	void SetContextInfo(class UObject* InContextObject, const class FName& InContext);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_Ticket")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_Ticket")
	}
	static class UPL_Ticket* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_Ticket>();
	}
};
DUMPER7_ASSERTS_UPL_Ticket;

// Class PL_Core.PL_Ticketer
// 0x0050 (0x0078 - 0x0028)
class UPL_Ticketer final : public UObject
{
public:
	TMulticastInlineDelegate<void(class UPL_Ticket* Ticket)> OnTicketAcquired;                       // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UPL_Ticket* Ticket)> OnTicketRelinquished;                   // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UPL_Ticketer* Ticketer)> OnTicketerActivated;                // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UPL_Ticketer* Ticketer)> OnTicketerCleared;                  // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TArray<TWeakObjectPtr<class UPL_Ticket>>      Tickets;                                           // 0x0068(0x0010)(Edit, ZeroConstructor, EditConst, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	class UPL_Ticket* GetTicket(class UObject* ContextObject, const class FName Context);
	void ReleaseAllActiveTickets();

	bool HasActiveTickets() const;
	int32 NumActiveTickets() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_Ticketer")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_Ticketer")
	}
	static class UPL_Ticketer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_Ticketer>();
	}
};
DUMPER7_ASSERTS_UPL_Ticketer;

// Class PL_Core.PL_TraceUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_TraceUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_TraceUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_TraceUtils")
	}
	static class UPL_TraceUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_TraceUtils>();
	}
};
DUMPER7_ASSERTS_UPL_TraceUtils;

// Class PL_Core.PL_VectorUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_VectorUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool K2_IsNearlyZero2D(const struct FVector& Vector, double Tolerance);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_VectorUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_VectorUtils")
	}
	static class UPL_VectorUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_VectorUtils>();
	}
};
DUMPER7_ASSERTS_UPL_VectorUtils;

// Class PL_Core.PL_WorldWidgetInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_WorldWidgetInterface final
{
public:
	struct FVector2D ModifyWorldWidgetDrawSize(const struct FVector2D& CurrentDrawSize);
	void UpdateWidgetOffScreenInformation(bool bWidgetMovedToKeepOnScreen, const struct FVector2D& MovedDirection);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WorldWidgetInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WorldWidgetInterface")
	}
	static class IPL_WorldWidgetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_WorldWidgetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_WorldWidgetInterface;

// Class PL_Core.PL_WorldWidgetSourceInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_WorldWidgetSourceInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WorldWidgetSourceInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WorldWidgetSourceInterface")
	}
	static class IPL_WorldWidgetSourceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_WorldWidgetSourceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_WorldWidgetSourceInterface;

// Class PL_Core.PL_OverlapActor
// 0x0030 (0x0350 - 0x0320)
class APL_OverlapActor : public AActor
{
public:
	uint8                                         Pad_320[0x8];                                      // 0x0320(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  GameplayTags;                                      // 0x0328(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	class UPrimitiveComponent*                    OverlapVolume;                                     // 0x0348(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_OverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_OverlapActor")
	}
	static class APL_OverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_OverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_OverlapActor;

// Class PL_Core.PL_BoxOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_BoxOverlapActor : public APL_OverlapActor
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BoxOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BoxOverlapActor")
	}
	static class APL_BoxOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_BoxOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_BoxOverlapActor;

// Class PL_Core.PL_KillZBoxOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_KillZBoxOverlapActor : public APL_BoxOverlapActor
{
public:
	void ComponentEnteredVolume(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_KillZBoxOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_KillZBoxOverlapActor")
	}
	static class APL_KillZBoxOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_KillZBoxOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_KillZBoxOverlapActor;

// Class PL_Core.PL_SphereOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_SphereOverlapActor : public APL_OverlapActor
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SphereOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SphereOverlapActor")
	}
	static class APL_SphereOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_SphereOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_SphereOverlapActor;

// Class PL_Core.PL_KillZSphereOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_KillZSphereOverlapActor : public APL_SphereOverlapActor
{
public:
	void ComponentEnteredVolume(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_KillZSphereOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_KillZSphereOverlapActor")
	}
	static class APL_KillZSphereOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_KillZSphereOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_KillZSphereOverlapActor;

// Class PL_Core.PL_CapsuleOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_CapsuleOverlapActor : public APL_OverlapActor
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CapsuleOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CapsuleOverlapActor")
	}
	static class APL_CapsuleOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_CapsuleOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_CapsuleOverlapActor;

// Class PL_Core.PL_KillZCapsuleOverlapActor
// 0x0000 (0x0350 - 0x0350)
class APL_KillZCapsuleOverlapActor final : public APL_CapsuleOverlapActor
{
public:
	void ComponentEnteredVolume(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_KillZCapsuleOverlapActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_KillZCapsuleOverlapActor")
	}
	static class APL_KillZCapsuleOverlapActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_KillZCapsuleOverlapActor>();
	}
};
DUMPER7_ASSERTS_APL_KillZCapsuleOverlapActor;

// Class PL_Core.PL_PostProcessVolume
// 0x0000 (0x0AD0 - 0x0AD0)
class APL_PostProcessVolume : public APostProcessVolume
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PostProcessVolume")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PostProcessVolume")
	}
	static class APL_PostProcessVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_PostProcessVolume>();
	}
};
DUMPER7_ASSERTS_APL_PostProcessVolume;

// Class PL_Core.PL_Blackboard
// 0x0108 (0x0130 - 0x0028)
class UPL_Blackboard final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPL_ResetSettings                      ResetSettings;                                     // 0x0030(0x0004)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
	bool                                          bShouldSaveAndLoad;                                // 0x0034(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPL_BlackboardData                     BlackboardData;                                    // 0x0038(0x0010)(Edit, Net, RepNotify, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FPL_BlackboardData                     BlackboardResetData;                               // 0x0048(0x0010)(Transient, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_58[0xC8];                                      // 0x0058(0x00C8)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPL_BlackboardEntry>            Entries;                                           // 0x0120(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

public:
	void OnGameInstancePostInit(class UGameInstance* GameInstance);
	void OnGameModeInitialized(class AGameModeBase* GameModeBase);
	void OnPostLoadData(TScriptInterface<class IPL_PersistenceSystemInterface> PersistenceSystem);
	void OnRep_BlackboardData(const struct FPL_BlackboardData& PreviousData);

	EPL_ResetPolicy GetResetPolicy() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_Blackboard")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_Blackboard")
	}
	static class UPL_Blackboard* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_Blackboard>();
	}
};
DUMPER7_ASSERTS_UPL_Blackboard;

// Class PL_Core.PL_BlackboardListener
// 0x0028 (0x0050 - 0x0028)
class UPL_BlackboardListener : public UObject
{
public:
	struct FGameplayTagContainer                  BlackboardKeys;                                    // 0x0028(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPrivate)
	class UPL_Blackboard*                         Blackboard;                                        // 0x0048(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate, TObjectPtr)

public:
	void OnBlackboardValueChanged(const struct FGameplayTag& Key, const struct FPL_BlackboardEntry& Entry);
	void OnInitialize();
	void OnPostBlackboardDataLoaded();
	void OnPreBlackboardDataLoaded();

	class UPL_Blackboard* GetBlackboard() const;
	const struct FGameplayTagContainer GetBlackboardKeys() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardListener")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardListener")
	}
	static class UPL_BlackboardListener* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardListener>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardListener;

// Class PL_Core.PL_BlackboardUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_BlackboardUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool AddDoubleToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, double Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddFloatToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, float Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddIntToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int32 Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddRotatorToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FRotator& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddStringToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const class FString& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddTagsToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FGameplayTagContainer& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddTagToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FGameplayTag& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool AddVectorToBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FVector& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static void ClearBlackboardValue(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool ClearBlackbordDataValue(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName);
	static bool CreateBlackboardDataBoolEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const bool bValue);
	static bool CreateBlackboardDataClassEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UClass* Value);
	static bool CreateBlackboardDataDoubleEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const double Value);
	static bool CreateBlackboardDataEnumEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int64 Value);
	static bool CreateBlackboardDataFloatEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const float Value);
	static bool CreateBlackboardDataGameplayTagContainerEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FGameplayTagContainer& Value);
	static bool CreateBlackboardDataGameplayTagEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FGameplayTag& Value);
	static bool CreateBlackboardDataInt64Entry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int64 Value);
	static bool CreateBlackboardDataIntEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int32 Value);
	static bool CreateBlackboardDataNameEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const class FName Value);
	static bool CreateBlackboardDataObjectEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UObject* Value);
	static bool CreateBlackboardDataRotatorEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FRotator& Value);
	static bool CreateBlackboardDataSoftClassPathEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FSoftObjectPath& Value);
	static bool CreateBlackboardDataSoftClassPtrEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const TSoftClassPtr<class UClass>& Value);
	static bool CreateBlackboardDataSoftObjectPathEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FSoftObjectPath& Value);
	static bool CreateBlackboardDataSoftObjectPtrEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const TSoftObjectPtr<class UObject>& Value);
	static bool CreateBlackboardDataStringEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const class FString& Value);
	static bool CreateBlackboardDataVectorEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FVector& Value);
	static bool FindBlackboardDataEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FPL_BlackboardEntry* Entry);
	static bool GetBlackboardDataValueAsActor(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class AActor** OutValue);
	static bool GetBlackboardDataValueAsBool(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, bool* bOutValue);
	static bool GetBlackboardDataValueAsClass(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UClass** OutValue);
	static bool GetBlackboardDataValueAsDouble(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, double* OutValue);
	static bool GetBlackboardDataValueAsEnum(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, int64* OutValue);
	static bool GetBlackboardDataValueAsFloat(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, float* OutValue);
	static bool GetBlackboardDataValueAsGameplayTag(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FGameplayTag* OutValue);
	static bool GetBlackboardDataValueAsGameplayTagContainer(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FGameplayTagContainer* OutValue);
	static bool GetBlackboardDataValueAsInt(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, int32* OutValue);
	static bool GetBlackboardDataValueAsInt64(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, int64* OutValue);
	static bool GetBlackboardDataValueAsName(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class FName* OutValue);
	static bool GetBlackboardDataValueAsObject(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UObject** OutValue);
	static bool GetBlackboardDataValueAsRotator(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FRotator* OutValue);
	static bool GetBlackboardDataValueAsSoftClassPath(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FSoftObjectPath* OutValue);
	static bool GetBlackboardDataValueAsSoftClassPtr(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, TSoftClassPtr<class UClass>* OutValue);
	static bool GetBlackboardDataValueAsSoftObjectPath(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FSoftObjectPath* OutValue);
	static bool GetBlackboardDataValueAsSoftObjectPtr(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, TSoftObjectPtr<class UObject>* OutValue);
	static bool GetBlackboardDataValueAsString(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class FString* OutValue);
	static bool GetBlackboardDataValueAsVector(const struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, struct FVector* OutValue);
	static bool GetBlackboardValueAsActor(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class AActor** OutValue);
	static bool GetBlackboardValueAsBool(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, bool* bOutValue);
	static bool GetBlackboardValueAsClass(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, TSoftClassPtr<class UClass>* OutValue);
	static bool GetBlackboardValueAsDouble(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, double* OutValue);
	static bool GetBlackboardValueAsEnum(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int64* OutValue);
	static bool GetBlackboardValueAsFloat(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, float* OutValue);
	static bool GetBlackboardValueAsGameplayTag(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, struct FGameplayTag* OutValue);
	static bool GetBlackboardValueAsGameplayTagContainer(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, struct FGameplayTagContainer* OutValue);
	static bool GetBlackboardValueAsInt(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int32* OutValue);
	static bool GetBlackboardValueAsInt64(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int64* OutValue);
	static bool GetBlackboardValueAsName(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class FName* OutValue);
	static bool GetBlackboardValueAsObject(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class UObject** OutValue);
	static bool GetBlackboardValueAsRotator(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, struct FRotator* OutValue);
	static bool GetBlackboardValueAsSoftObjectPtr(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, TSoftObjectPtr<class UObject>* OutValue);
	static bool GetBlackboardValueAsString(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class FString* OutValue);
	static bool GetBlackboardValueAsVector(const class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, struct FVector* OutValue);
	static class UPL_Blackboard* GetGlobalBlackboard(const class UObject* WorldContextObject);
	static bool MergeTagsFromBlackboardValues(const class UPL_Blackboard* Blackboard, const TArray<struct FGameplayTag>& KeyNames, struct FGameplayTagContainer* OutValue);
	static bool MergeTagsFromGlobalBlackboardValues(const class UObject* WorldContextObject, const TArray<struct FGameplayTag>& KeyNames, struct FGameplayTagContainer* OutValue);
	static int32 RemoveBlackboardDataEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName);
	static bool RenameBlackboardDataEntry(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& OldName, const struct FGameplayTag& NewName);
	static void ResetGlobalBlackboard(const class UObject* WorldContextObject);
	static void ResetGlobalBlackboardEntries(const class UObject* WorldContextObject, const TArray<struct FGameplayTag>& Keys);
	static void ResetGlobalBlackboardEntry(const class UObject* WorldContextObject, const struct FGameplayTag& Key);
	static bool SetBlackboardDataValueAsBool(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const bool bValue);
	static bool SetBlackboardDataValueAsClass(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UClass* Value);
	static bool SetBlackboardDataValueAsDouble(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const double Value);
	static bool SetBlackboardDataValueAsEnum(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int64 Value);
	static bool SetBlackboardDataValueAsFloat(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const float Value);
	static bool SetBlackboardDataValueAsGameplayTag(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FGameplayTag& Value);
	static bool SetBlackboardDataValueAsGameplayTagContainer(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FGameplayTagContainer& Value);
	static bool SetBlackboardDataValueAsInt(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int32 Value);
	static bool SetBlackboardDataValueAsInt64(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const int64 Value);
	static bool SetBlackboardDataValueAsName(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const class FName Value);
	static bool SetBlackboardDataValueAsObject(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, class UObject* Value);
	static bool SetBlackboardDataValueAsRotator(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FRotator& Value);
	static bool SetBlackboardDataValueAsSoftClassPath(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FSoftObjectPath& Value);
	static bool SetBlackboardDataValueAsSoftClassPtr(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const TSoftClassPtr<class UClass>& Value);
	static bool SetBlackboardDataValueAsSoftObjectPath(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FSoftObjectPath& Value);
	static bool SetBlackboardDataValueAsSoftObjectPtr(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const TSoftObjectPtr<class UObject>& Value);
	static bool SetBlackboardDataValueAsString(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const class FString& Value);
	static bool SetBlackboardDataValueAsVector(struct FPL_BlackboardData& BlackboardData, const struct FGameplayTag& KeyName, const struct FVector& Value);
	static bool SetBlackboardValueAsBool(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const bool bValue, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsClass(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class UClass* Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsDouble(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, double Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsEnum(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int64 Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsFloat(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, float Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsGameplayTag(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FGameplayTag& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsGameplayTagContainer(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FGameplayTagContainer& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsInt(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int32 Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsInt64(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, int64 Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsName(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class FName Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsObject(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, class UObject* Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsRotator(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FRotator& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsString(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const class FString& Value, const EPL_PersistenceBehavior PersistenceBehavior);
	static bool SetBlackboardValueAsVector(class UPL_Blackboard* Blackboard, const struct FGameplayTag& KeyName, const struct FVector& Value, const EPL_PersistenceBehavior PersistenceBehavior);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardUtils")
	}
	static class UPL_BlackboardUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardUtils>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardUtils;

// Class PL_Core.PL_GlobalBlackboardManager
// 0x0028 (0x0058 - 0x0030)
class UPL_GlobalBlackboardManager final : public UGameInstanceSubsystem
{
public:
	class UPL_Blackboard*                         GlobalBlackboard;                                  // 0x0030(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	TArray<class UPL_BlackboardListener*>         GlobalBlackboardListeners;                         // 0x0038(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)
	uint8                                         Pad_48[0x10];                                      // 0x0048(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UPL_Blackboard* GetBlackboard() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GlobalBlackboardManager")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GlobalBlackboardManager")
	}
	static class UPL_GlobalBlackboardManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GlobalBlackboardManager>();
	}
};
DUMPER7_ASSERTS_UPL_GlobalBlackboardManager;

// Class PL_Core.PL_SettingsBase
// 0x0000 (0x0038 - 0x0038)
class UPL_SettingsBase : public UDeveloperSettings
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SettingsBase")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SettingsBase")
	}
	static class UPL_SettingsBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_SettingsBase>();
	}
};
DUMPER7_ASSERTS_UPL_SettingsBase;

// Class PL_Core.PL_GlobalBlackboardSettings
// 0x0038 (0x0070 - 0x0038)
class UPL_GlobalBlackboardSettings final : public UPL_SettingsBase
{
public:
	TSoftObjectPtr<class UPL_Blackboard>          GlobalBlackboard;                                  // 0x0038(0x0028)(Edit, Config, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<TSoftClassPtr<class UClass>>           GlobalBlackboardListeners;                         // 0x0060(0x0010)(Edit, ZeroConstructor, Config, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	static const class UPL_GlobalBlackboardSettings* Get();

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GlobalBlackboardSettings")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GlobalBlackboardSettings")
	}
	static class UPL_GlobalBlackboardSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GlobalBlackboardSettings>();
	}
};
DUMPER7_ASSERTS_UPL_GlobalBlackboardSettings;

// Class PL_Core.PL_BlackboardVariant
// 0x0000 (0x0028 - 0x0028)
class UPL_BlackboardVariant : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant")
	}
	static class UPL_BlackboardVariant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant;

// Class PL_Core.PL_BlackboardVariant_Bool
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Bool final : public UPL_BlackboardVariant
{
public:
	bool                                          bValue;                                            // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Bool")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Bool")
	}
	static class UPL_BlackboardVariant_Bool* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Bool>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Bool;

// Class PL_Core.PL_BlackboardVariant_Class
// 0x0030 (0x0058 - 0x0028)
class UPL_BlackboardVariant_Class final : public UPL_BlackboardVariant
{
public:
	TSubclassOf<class UObject>                    BaseClass;                                         // 0x0028(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	TSoftClassPtr<class UClass>                   Value;                                             // 0x0030(0x0028)(Edit, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Class")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Class")
	}
	static class UPL_BlackboardVariant_Class* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Class>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Class;

// Class PL_Core.PL_BlackboardVariant_Double
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Double final : public UPL_BlackboardVariant
{
public:
	double                                        Value;                                             // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Double")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Double")
	}
	static class UPL_BlackboardVariant_Double* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Double>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Double;

// Class PL_Core.PL_BlackboardVariant_Enum
// 0x0028 (0x0050 - 0x0028)
class UPL_BlackboardVariant_Enum final : public UPL_BlackboardVariant
{
public:
	class UEnum*                                  EnumType;                                          // 0x0028(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class FString                                 EnumName;                                          // 0x0030(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bIsEnumNameValid : 1;                              // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, EditConst, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	int64                                         Value;                                             // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Enum")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Enum")
	}
	static class UPL_BlackboardVariant_Enum* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Enum>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Enum;

// Class PL_Core.PL_BlackboardVariant_Float
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Float final : public UPL_BlackboardVariant
{
public:
	float                                         Value;                                             // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Float")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Float")
	}
	static class UPL_BlackboardVariant_Float* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Float>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Float;

// Class PL_Core.PL_BlackboardVariant_GameplayTag
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_GameplayTag final : public UPL_BlackboardVariant
{
public:
	struct FGameplayTag                           Value;                                             // 0x0028(0x0008)(Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_GameplayTag")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_GameplayTag")
	}
	static class UPL_BlackboardVariant_GameplayTag* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_GameplayTag>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_GameplayTag;

// Class PL_Core.PL_BlackboardVariant_GameplayTagContainer
// 0x0020 (0x0048 - 0x0028)
class UPL_BlackboardVariant_GameplayTagContainer final : public UPL_BlackboardVariant
{
public:
	struct FGameplayTagContainer                  Value;                                             // 0x0028(0x0020)(Edit, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_GameplayTagContainer")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_GameplayTagContainer")
	}
	static class UPL_BlackboardVariant_GameplayTagContainer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_GameplayTagContainer>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_GameplayTagContainer;

// Class PL_Core.PL_BlackboardVariant_Int
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Int final : public UPL_BlackboardVariant
{
public:
	int32                                         Value;                                             // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Int")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Int")
	}
	static class UPL_BlackboardVariant_Int* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Int>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Int;

// Class PL_Core.PL_BlackboardVariant_Int64
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Int64 final : public UPL_BlackboardVariant
{
public:
	int64                                         Value;                                             // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Int64")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Int64")
	}
	static class UPL_BlackboardVariant_Int64* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Int64>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Int64;

// Class PL_Core.PL_BlackboardVariant_Name
// 0x0008 (0x0030 - 0x0028)
class UPL_BlackboardVariant_Name final : public UPL_BlackboardVariant
{
public:
	class FName                                   Value;                                             // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Name")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Name")
	}
	static class UPL_BlackboardVariant_Name* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Name>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Name;

// Class PL_Core.PL_BlackboardVariant_Object
// 0x0030 (0x0058 - 0x0028)
class UPL_BlackboardVariant_Object final : public UPL_BlackboardVariant
{
public:
	TSubclassOf<class UObject>                    BaseClass;                                         // 0x0028(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoClear, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	TSoftObjectPtr<class UObject>                 Value;                                             // 0x0030(0x0028)(Edit, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Object")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Object")
	}
	static class UPL_BlackboardVariant_Object* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Object>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Object;

// Class PL_Core.PL_BlackboardVariant_Rotator
// 0x0018 (0x0040 - 0x0028)
class UPL_BlackboardVariant_Rotator final : public UPL_BlackboardVariant
{
public:
	struct FRotator                               Value;                                             // 0x0028(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Rotator")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Rotator")
	}
	static class UPL_BlackboardVariant_Rotator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Rotator>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Rotator;

// Class PL_Core.PL_BlackboardVariant_String
// 0x0010 (0x0038 - 0x0028)
class UPL_BlackboardVariant_String final : public UPL_BlackboardVariant
{
public:
	class FString                                 Value;                                             // 0x0028(0x0010)(Edit, ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_String")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_String")
	}
	static class UPL_BlackboardVariant_String* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_String>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_String;

// Class PL_Core.PL_BlackboardVariant_Vector
// 0x0018 (0x0040 - 0x0028)
class UPL_BlackboardVariant_Vector final : public UPL_BlackboardVariant
{
public:
	struct FVector                                Value;                                             // 0x0028(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BlackboardVariant_Vector")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BlackboardVariant_Vector")
	}
	static class UPL_BlackboardVariant_Vector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BlackboardVariant_Vector>();
	}
};
DUMPER7_ASSERTS_UPL_BlackboardVariant_Vector;

// Class PL_Core.PL_CollisionUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_CollisionUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool DoComponentsHaveBlockingCollision(const class USceneComponent* ComponentA, const class USceneComponent* ComponentB);
	static TSet<class AActor*> FindStuckActors(const class AActor* BlockingActor);
	static void SetActorMoveIgnoreBlockingComponents(class AActor* ActorA, class AActor* ActorB, bool bShouldMoveIgnore);
	static void SetMoveIgnoreBlockingComponents(class UPrimitiveComponent* ComponentA, class UPrimitiveComponent* ComponentB, bool bShouldMoveIgnore);
	static bool TryCalculateUnstuckOffset(const class AActor* BlockingActor, const class AActor* StuckActor, struct FVector* OutOffset);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CollisionUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CollisionUtils")
	}
	static class UPL_CollisionUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CollisionUtils>();
	}
};
DUMPER7_ASSERTS_UPL_CollisionUtils;

// Class PL_Core.PL_ArrayUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ArrayUtils final : public UBlueprintFunctionLibrary
{
public:
	static int32 GetNextShuffleIndexAccessArrayEntry(struct FPL_ShuffleIndexAccessArray& InOutArray, int32 ArraySize);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ArrayUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ArrayUtils")
	}
	static class UPL_ArrayUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ArrayUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ArrayUtils;

// Class PL_Core.PL_SubObjectBase
// 0x0000 (0x0028 - 0x0028)
class UPL_SubObjectBase : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_SubObjectBase")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_SubObjectBase")
	}
	static class UPL_SubObjectBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_SubObjectBase>();
	}
};
DUMPER7_ASSERTS_UPL_SubObjectBase;

// Class PL_Core.PL_WorldSettings
// 0x0018 (0x0568 - 0x0550)
class APL_WorldSettings : public AWorldSettings
{
public:
	uint8                                         Pad_550[0x8];                                      // 0x0550(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class APlayerState* PlayerState)> OnPauserPlayerStateChanged;      // 0x0558(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WorldSettings")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WorldSettings")
	}
	static class APL_WorldSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_WorldSettings>();
	}
};
DUMPER7_ASSERTS_APL_WorldSettings;

// Class PL_Core.PL_ComparisonOperatorUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ComparisonOperatorUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool DoesValuePassComparison(const class FString& A, const class FString& B, const EPL_TextComparisonOperator Operator, const ESearchCase SearchCase);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ComparisonOperatorUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ComparisonOperatorUtils")
	}
	static class UPL_ComparisonOperatorUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ComparisonOperatorUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ComparisonOperatorUtils;

// Class PL_Core.PL_VfxSettingsObject
// 0x0050 (0x0078 - 0x0028)
class UPL_VfxSettingsObject final : public UObject
{
public:
	struct FPL_VfxSettings                        Value;                                             // 0x0028(0x0050)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_VfxSettingsObject")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_VfxSettingsObject")
	}
	static class UPL_VfxSettingsObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_VfxSettingsObject>();
	}
};
DUMPER7_ASSERTS_UPL_VfxSettingsObject;

// Class PL_Core.PL_DebugOverlayComponentWidget
// 0x0000 (0x0340 - 0x0340)
class UPL_DebugOverlayComponentWidget final : public UUserWidget
{
public:
	void FrequentTick(const class UPL_DebugOverlayWidget* Parent, float InDeltaTime);
	void SparseTick(const class UPL_DebugOverlayWidget* Parent, float InDeltaTime);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DebugOverlayComponentWidget")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DebugOverlayComponentWidget")
	}
	static class UPL_DebugOverlayComponentWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DebugOverlayComponentWidget>();
	}
};
DUMPER7_ASSERTS_UPL_DebugOverlayComponentWidget;

// Class PL_Core.PL_DebugOverlaySubsystem
// 0x0028 (0x0058 - 0x0030)
class UPL_DebugOverlaySubsystem final : public UGameInstanceSubsystem
{
public:
	class UPL_DebugOverlayWidget*                 DebugWidgetInstance;                               // 0x0030(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_38[0x20];                                      // 0x0038(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DebugOverlaySubsystem")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DebugOverlaySubsystem")
	}
	static class UPL_DebugOverlaySubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DebugOverlaySubsystem>();
	}
};
DUMPER7_ASSERTS_UPL_DebugOverlaySubsystem;

// Class PL_Core.PL_DebugOverlayWidget
// 0x0040 (0x0380 - 0x0340)
class UPL_DebugOverlayWidget final : public UUserWidget
{
public:
	float                                         SparseTickInterval;                                // 0x0340(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         SmoothDeltaTimeSpan;                               // 0x0344(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<struct FPL_DebugOverlayComponentInstance> DebugOverlayComponents;                         // 0x0348(0x0010)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, DuplicateTransient, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         Pad_358[0x28];                                     // 0x0358(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void FrequentTick(float DeltaTime);
	void SparseTick(float DeltaTime);

	struct FPL_DynamicResolutionStateInfos GetDynamicResolutionStateInfos() const;
	float GetFPSSpike() const;
	float GetLatestDeltaTime() const;
	float GetLatestFPS() const;
	float GetSmoothFPS() const;
	float GetTotalMemoryInGB() const;
	float GetUsedMemoryInGB() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DebugOverlayWidget")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DebugOverlayWidget")
	}
	static class UPL_DebugOverlayWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DebugOverlayWidget>();
	}
};
DUMPER7_ASSERTS_UPL_DebugOverlayWidget;

// Class PL_Core.PL_DebugUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_DebugUtils final : public UBlueprintFunctionLibrary
{
public:
	static void PL_PrintString(const class UObject* WorldContextObject, const class FString& InString, bool bPrintToScreen, bool bPrintToLog, const struct FLinearColor& TextColor, float Duration);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_DebugUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_DebugUtils")
	}
	static class UPL_DebugUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_DebugUtils>();
	}
};
DUMPER7_ASSERTS_UPL_DebugUtils;

// Class PL_Core.PL_EnhancedInputComponent
// 0x0020 (0x01A0 - 0x0180)
class UPL_EnhancedInputComponent final : public UEnhancedInputComponent
{
public:
	TArray<struct FInstancedStruct>               Actions;                                           // 0x0180(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_190[0x10];                                     // 0x0190(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_EnhancedInputComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_EnhancedInputComponent")
	}
	static class UPL_EnhancedInputComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_EnhancedInputComponent>();
	}
};
DUMPER7_ASSERTS_UPL_EnhancedInputComponent;

// Class PL_Core.PL_ActorBaseListenerInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_ActorBaseListenerInterface final
{
public:
	void ReceiveStartBeingBase(class AActor* BasedActor, class UPrimitiveComponent* NewBase, class UPrimitiveComponent* OldBase);
	void ReceiveStopBeingBase(class AActor* BasedActor, class UPrimitiveComponent* NewBase, class UPrimitiveComponent* OldBase);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ActorBaseListenerInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ActorBaseListenerInterface")
	}
	static class IPL_ActorBaseListenerInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_ActorBaseListenerInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_ActorBaseListenerInterface;

// Class PL_Core.PL_LevelSequencePlaybackAction
// 0x0000 (0x0028 - 0x0028)
class UPL_LevelSequencePlaybackAction : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LevelSequencePlaybackAction")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LevelSequencePlaybackAction")
	}
	static class UPL_LevelSequencePlaybackAction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LevelSequencePlaybackAction>();
	}
};
DUMPER7_ASSERTS_UPL_LevelSequencePlaybackAction;

// Class PL_Core.PL_ActorPossessionAction
// 0x0000 (0x0028 - 0x0028)
class UPL_ActorPossessionAction : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ActorPossessionAction")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ActorPossessionAction")
	}
	static class UPL_ActorPossessionAction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ActorPossessionAction>();
	}
};
DUMPER7_ASSERTS_UPL_ActorPossessionAction;

// Class PL_Core.PL_LevelSequenceActor
// 0x0008 (0x03D0 - 0x03C8)
class APL_LevelSequenceActor : public ALevelSequenceActor
{
public:
	class UPL_LevelSequencePlaybackSettings*      CustomPlaybackSettings;                            // 0x03C8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LevelSequenceActor")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LevelSequenceActor")
	}
	static class APL_LevelSequenceActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APL_LevelSequenceActor>();
	}
};
DUMPER7_ASSERTS_APL_LevelSequenceActor;

// Class PL_Core.PL_LevelSequencePlaybackSettings
// 0x0028 (0x0058 - 0x0030)
class UPL_LevelSequencePlaybackSettings final : public UDataAsset
{
public:
	TArray<class UPL_LevelSequencePlaybackAction*> Actions;                                          // 0x0030(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)
	TArray<class UPL_ActorPossessionAction*>      ActorPossessionActions;                            // 0x0040(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)
	bool                                          bWaitForPlayerToLand;                              // 0x0050(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_51[0x7];                                       // 0x0051(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LevelSequencePlaybackSettings")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LevelSequencePlaybackSettings")
	}
	static class UPL_LevelSequencePlaybackSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LevelSequencePlaybackSettings>();
	}
};
DUMPER7_ASSERTS_UPL_LevelSequencePlaybackSettings;

// Class PL_Core.PL_LevelSequencePlayer
// 0x0040 (0x05C8 - 0x0588)
class UPL_LevelSequencePlayer final : public ULevelSequencePlayer
{
public:
	class UPL_LevelSequencePlaybackSettings*      CustomPlaybackSettings;                            // 0x0588(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	struct FPL_LevelSequencePlaybackActionsData   ActionsData;                                       // 0x0590(0x0010)(Transient, DuplicateTransient, Protected, NativeAccessSpecifierProtected)
	struct FPL_ActorPossessionActionDataContainer ActorPossessionDataContainer;                      // 0x05A0(0x0010)(Transient, DuplicateTransient, Protected, NativeAccessSpecifierProtected)
	TArray<class AActor*>                         ModifiedActors;                                    // 0x05B0(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)
	uint8                                         Pad_5C0[0x8];                                      // 0x05C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void HandleEvent(const struct FGameplayTag& EventTag);
	void OnPauserChanged(class APlayerState* PlayerState);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LevelSequencePlayer")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LevelSequencePlayer")
	}
	static class UPL_LevelSequencePlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LevelSequencePlayer>();
	}
};
//DUMPER7_ASSERTS_UPL_LevelSequencePlayer;

// Class PL_Core.PL_LevelSequenceUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_LevelSequenceUtils final : public UBlueprintFunctionLibrary
{
public:
	static void PlayToEndAndStop(class ULevelSequencePlayer* SequencePlayer);
	static void PlayToTheLastFrameAndPause(class ULevelSequencePlayer* SequencePlayer);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_LevelSequenceUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_LevelSequenceUtils")
	}
	static class UPL_LevelSequenceUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_LevelSequenceUtils>();
	}
};
DUMPER7_ASSERTS_UPL_LevelSequenceUtils;

// Class PL_Core.PL_Movement
// 0x0008 (0x0030 - 0x0028)
class UPL_Movement : public UObject
{
public:
	EPL_MovementInstancingPolicy                  InstancingPolicy;                                  // 0x0028(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_Movement")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_Movement")
	}
	static class UPL_Movement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_Movement>();
	}
};
DUMPER7_ASSERTS_UPL_Movement;

// Class PL_Core.PL_ContinualMovement
// 0x0000 (0x0030 - 0x0030)
class UPL_ContinualMovement : public UPL_Movement
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ContinualMovement")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ContinualMovement")
	}
	static class UPL_ContinualMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ContinualMovement>();
	}
};
DUMPER7_ASSERTS_UPL_ContinualMovement;

// Class PL_Core.PL_FallingMovement
// 0x0020 (0x0050 - 0x0030)
class UPL_FallingMovement : public UPL_Movement
{
public:
	struct FPL_StepUpSettings                     StepUpSettings;                                    // 0x0030(0x0020)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_FallingMovement")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_FallingMovement")
	}
	static class UPL_FallingMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_FallingMovement>();
	}
};
DUMPER7_ASSERTS_UPL_FallingMovement;

// Class PL_Core.PL_CharacterMovementComponent
// 0x0050 (0x1030 - 0x0FE0)
#pragma pack(push, 0x1)
class alignas(0x10) UPL_CharacterMovementComponent : public UCharacterMovementComponent
{
public:
	uint8                                         Pad_FE0[0x8];                                      // 0x0FE0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const struct FHitResult& Hit, const struct FVector& VelocityOnLand)> OnPostLanded; // 0x0FE8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FPL_ConnectedComponentMovements        ConnectedComponentMovements;                       // 0x0FF8(0x0010)(Transient, DuplicateTransient, NativeAccessSpecifierPrivate)
	struct FGameplayTagContainer                  GameplayTagContainer;                              // 0x1008(0x0020)(Edit, DisableEditOnInstance, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CharacterMovementComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CharacterMovementComponent")
	}
	static class UPL_CharacterMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CharacterMovementComponent>();
	}
};
#pragma pack(pop)
DUMPER7_ASSERTS_UPL_CharacterMovementComponent;

// Class PL_Core.PL_ExtendableCharacterMovementComponent
// 0x0080 (0x10B0 - 0x1030)
class UPL_ExtendableCharacterMovementComponent : public UPL_CharacterMovementComponent
{
public:
	TSubclassOf<class UPL_Movement>               NoneMovementClass;                                 // 0x1028(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPL_Movement>               WalkingMovementClass;                              // 0x1030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPL_Movement>               NavWalkingMovementClass;                           // 0x1038(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPL_Movement>               FallingMovementClass;                              // 0x1040(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPL_Movement>               SwimmingMovementClass;                             // 0x1048(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPL_Movement>               FlyingMovementClass;                               // 0x1050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<TSubclassOf<class UPL_Movement>>       CustomMovementClasses;                             // 0x1058(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	class UPL_Movement*                           ActiveMovement;                                    // 0x1068(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           NoneMovement;                                      // 0x1070(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           WalkingMovement;                                   // 0x1078(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           NavWalkingMovement;                                // 0x1080(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           FallingMovement;                                   // 0x1088(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           SwimmingMovement;                                  // 0x1090(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UPL_Movement*                           FlyingMovement;                                    // 0x1098(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	TArray<class UPL_Movement*>                   CustomMovements;                                   // 0x10A0(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)

public:
	class UPL_Movement* GetCustomMovement(TSubclassOf<class UPL_Movement> TargetClass) const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ExtendableCharacterMovementComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ExtendableCharacterMovementComponent")
	}
	static class UPL_ExtendableCharacterMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ExtendableCharacterMovementComponent>();
	}
};
DUMPER7_ASSERTS_UPL_ExtendableCharacterMovementComponent;

// Class PL_Core.PL_PersistenceSystemInterface
// 0x0000 (0x0000 - 0x0000)
class IPL_PersistenceSystemInterface final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PersistenceSystemInterface")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PersistenceSystemInterface")
	}
	static class IPL_PersistenceSystemInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPL_PersistenceSystemInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_IPL_PersistenceSystemInterface;

// Class PL_Core.PL_NintendoUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_NintendoUtils final : public UBlueprintFunctionLibrary
{
public:
	static EPL_NintendoBoostMode GetBoostMode();
	static EPL_NintendoConsoleMode GetConsoleMode();

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_NintendoUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_NintendoUtils")
	}
	static class UPL_NintendoUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_NintendoUtils>();
	}
};
DUMPER7_ASSERTS_UPL_NintendoUtils;

// Class PL_Core.PL_ActorUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_ActorUtils final : public UBlueprintFunctionLibrary
{
public:
	static bool FilterActors(const TArray<TSubclassOf<class AActor>>& Container, const class AActor* ActorInQuestion);
	static TArray<class UObject*> GetAllInterfaceImplementors(class AActor* Actor, TSubclassOf<class IInterface> InterfaceClass);
	static class UObject* GetFirstInterfaceImplementor(class AActor* Actor, TSubclassOf<class IInterface> InterfaceClass);
	static class UObject* GetFirstInterfaceImplementorStartingFromComponent(class UActorComponent* ActorComponent, TSubclassOf<class IInterface> InterfaceClass);
	static TArray<class AActor*> GetOverlappingActors(const class UPrimitiveComponent* Source, const TArray<ECollisionChannel>& IgnoredChannels, const TSubclassOf<class AActor> ClassFilter);
	static void MoveIgnoreActorAdd(class APawn* Pawn, class AActor* ActorToIgnore);
	static void MoveIgnoreActorRemove(class APawn* Pawn, class AActor* ActorToIgnore);
	static void SetAllMeshesVisibility(class AActor* TargetActor, bool bNewVisibility);
	static void SetVelocity(const class AActor* Actor, const struct FVector& Velocity);
	static class AActor* SpawnActor(const class UObject* WorldContextObject, const TSubclassOf<class AActor>& ClassToSpawn, const struct FTransform& SpawnTransform, class AActor* Owner, class APawn* Instigator, const ESpawnActorCollisionHandlingMethod CollisionHandlingOverride);
	static class AActor* SpawnActorFromStaticData(const class UObject* WorldContextObject, const class UPL_StaticActorData* Data, const struct FTransform& SpawnTransform, class AActor* Owner, class APawn* Instigator, const ESpawnActorCollisionHandlingMethod CollisionHandlingOverride);
	static class AActor* SpawnActorFromStaticDataWithContext(const class UObject* WorldContextObject, const struct FPL_StaticDataSpawnContext& SpawnContext);
	static bool TryFindSocketTransform(const class AActor* Actor, const class FName& SocketName, struct FTransform* OutSocketTransform);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_ActorUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_ActorUtils")
	}
	static class UPL_ActorUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_ActorUtils>();
	}
};
DUMPER7_ASSERTS_UPL_ActorUtils;

// Class PL_Core.PL_AnimationUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_AnimationUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_AnimationUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_AnimationUtils")
	}
	static class UPL_AnimationUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_AnimationUtils>();
	}
};
DUMPER7_ASSERTS_UPL_AnimationUtils;

// Class PL_Core.PL_CharacterUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_CharacterUtils final : public UBlueprintFunctionLibrary
{
public:
	static void SetJumpCounter(class ACharacter* Character, const int32 JumpCurrentCount);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CharacterUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CharacterUtils")
	}
	static class UPL_CharacterUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CharacterUtils>();
	}
};
DUMPER7_ASSERTS_UPL_CharacterUtils;

// Class PL_Core.PL_GameplayStatics
// 0x0000 (0x0028 - 0x0028)
class UPL_GameplayStatics final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GameplayStatics")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GameplayStatics")
	}
	static class UPL_GameplayStatics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GameplayStatics>();
	}
};
DUMPER7_ASSERTS_UPL_GameplayStatics;

// Class PL_Core.PL_GameplayTagAssetUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_GameplayTagAssetUtils final : public UBlueprintFunctionLibrary
{
public:
	static class FText Conv_GameplayTagContainerToText(const struct FGameplayTagContainer& GameplayTagContainer);
	static class FText Conv_GameplayTagToText(const struct FGameplayTag& GameplayTag);
	static struct FGameplayTagContainer GetOwnedGameplayTags(const class UObject* Object);
	static struct FGameplayTagContainer GetOwnedGameplayTagsFromFirstImplementer(const class UObject* Object);
	static bool HasAllMatchingGameplayTags(const class UObject* Object, const struct FGameplayTagContainer& TagContainer);
	static bool HasAnyMatchingGameplayTags(const class UObject* Object, const struct FGameplayTagContainer& TagContainer);
	static bool HasMatchingGameplayTag(const class UObject* Object, const struct FGameplayTag& TagToCheck);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GameplayTagAssetUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GameplayTagAssetUtils")
	}
	static class UPL_GameplayTagAssetUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GameplayTagAssetUtils>();
	}
};
DUMPER7_ASSERTS_UPL_GameplayTagAssetUtils;

// Class PL_Core.PL_PlayerUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_PlayerUtils final : public UBlueprintFunctionLibrary
{
public:
	static class ULocalPlayer* GetLocalPlayerFromPrimaryPlayerController(const class UObject* WorldContextObject, const bool bRequiresValidUniqueId);
	static class AActor* GetStartSpot(const class AController* Controller);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PlayerUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PlayerUtils")
	}
	static class UPL_PlayerUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_PlayerUtils>();
	}
};
DUMPER7_ASSERTS_UPL_PlayerUtils;

// Class PL_Core.PL_StructUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_StructUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StructUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StructUtils")
	}
	static class UPL_StructUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StructUtils>();
	}
};
DUMPER7_ASSERTS_UPL_StructUtils;

// Class PL_Core.PL_VisualizationVolumeUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_VisualizationVolumeUtils final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_VisualizationVolumeUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_VisualizationVolumeUtils")
	}
	static class UPL_VisualizationVolumeUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_VisualizationVolumeUtils>();
	}
};
DUMPER7_ASSERTS_UPL_VisualizationVolumeUtils;

// Class PL_Core.PL_WorldUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_WorldUtils final : public UBlueprintFunctionLibrary
{
public:
	static double GetLoadingRange(const class UObject* WorldContextObject, const class FName GridName);
	static bool IsInRangeOfStreamingSource(const class UObject* WorldContextObject, const struct FVector& Location, const class FName GridName, const double StreamingSourceRadiusScale, const bool bProjectIn2D);
	static bool ResolveSoftObjectPathForWorldPartitioning(const class UObject* WorldContextObject, const struct FSoftObjectPath& Path, struct FSoftObjectPath* OutResolvedPath);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WorldUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WorldUtils")
	}
	static class UPL_WorldUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_WorldUtils>();
	}
};
DUMPER7_ASSERTS_UPL_WorldUtils;

// Class PL_Core.PL_RuntimeTraitsExtenderBase
// 0x0000 (0x0028 - 0x0028)
class UPL_RuntimeTraitsExtenderBase : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_RuntimeTraitsExtenderBase")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_RuntimeTraitsExtenderBase")
	}
	static class UPL_RuntimeTraitsExtenderBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_RuntimeTraitsExtenderBase>();
	}
};
//DUMPER7_ASSERTS_UPL_RuntimeTraitsExtenderBase;

// Class PL_Core.PL_PlatformTraitsExtender
// 0x0020 (0x0048 - 0x0028)
class UPL_PlatformTraitsExtender final : public UPL_RuntimeTraitsExtenderBase
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PlatformTraitsExtender")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PlatformTraitsExtender")
	}
	static class UPL_PlatformTraitsExtender* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_PlatformTraitsExtender>();
	}
};
//DUMPER7_ASSERTS_UPL_PlatformTraitsExtender;

// Class PL_Core.PL_RuntimeTraitsSubsystem
// 0x0068 (0x0098 - 0x0030)
class UPL_RuntimeTraitsSubsystem final : public UGameInstanceSubsystem
{
public:
	uint8                                         Pad_30[0x58];                                      // 0x0030(0x0058)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UPL_RuntimeTraitsExtenderBase*>  Extenders;                                         // 0x0088(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_RuntimeTraitsSubsystem")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_RuntimeTraitsSubsystem")
	}
	static class UPL_RuntimeTraitsSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_RuntimeTraitsSubsystem>();
	}
};
//DUMPER7_ASSERTS_UPL_RuntimeTraitsSubsystem;

// Class PL_Core.PL_CoreSettings
// 0x0078 (0x00B0 - 0x0038)
class UPL_CoreSettings final : public UPL_SettingsBase
{
public:
	float                                         MaxBillboardedUiVisibilityDistance;                // 0x0038(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSoftClassPtr<class UClass>                   DebugOverlayWidgetClass;                           // 0x0040(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         DebugOverlayZOrder;                                // 0x0068(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPL_DebugOverlayWidgetSettings> OverlayWidgets;                                    // 0x0070(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	bool                                          bSlateWorldWidgetZOrder;                           // 0x0080(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSlateWorldWidgetIgnoreNotVisibleWidgets;          // 0x0081(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_82[0x6];                                       // 0x0082(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UPL_WidgetScreenLayerSelection> WidgetScreenLayerSelection;                    // 0x0088(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableSteamInEditor;                              // 0x0090(0x0001)(Edit, BlueprintVisible, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPL_WorldWidgetSetup>           WorldWidgetLayers;                                 // 0x0098(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	int32                                         DefaultPlayerIndicatorScreenLayerIndex;            // 0x00A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	TArray<struct FPL_DebugOverlayWidgetSettings> GetOrderedOverlayWidgets() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_CoreSettings")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_CoreSettings")
	}
	static class UPL_CoreSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_CoreSettings>();
	}
};
DUMPER7_ASSERTS_UPL_CoreSettings;

// Class PL_Core.PL_StaticData
// 0x0008 (0x0030 - 0x0028)
class UPL_StaticData : public UObject
{
public:
	struct FGameplayTag                           ID;                                                // 0x0028(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StaticData")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StaticData")
	}
	static class UPL_StaticData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StaticData>();
	}
};
DUMPER7_ASSERTS_UPL_StaticData;

// Class PL_Core.PL_GameplayCueSetup
// 0x0008 (0x0038 - 0x0030)
class UPL_GameplayCueSetup final : public UPL_StaticData
{
public:
	struct FGameplayTag                           GameplayCueTag;                                    // 0x0030(0x0008)(Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_GameplayCueSetup")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_GameplayCueSetup")
	}
	static class UPL_GameplayCueSetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_GameplayCueSetup>();
	}
};
DUMPER7_ASSERTS_UPL_GameplayCueSetup;

// Class PL_Core.PL_StaticActorData
// 0x0030 (0x0060 - 0x0030)
class UPL_StaticActorData final : public UPrimaryDataAsset
{
public:
	TSubclassOf<class AActor>                     ActorClass;                                        // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UPL_StaticActorData*                    Parent;                                            // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	TArray<class UPL_StaticData*>                 StaticData;                                        // 0x0040(0x0010)(Edit, ExportObject, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)
	TArray<class UPL_StaticData*>                 MergedStaticData;                                  // 0x0050(0x0010)(Edit, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)

public:
	TSubclassOf<class AActor> GetActorClass() const;
	const class UPL_StaticData* GetData(TSubclassOf<class UPL_StaticData> TargetClass, const struct FGameplayTag& TagId) const;
	const class UPL_StaticData* GetDataByClass(TSubclassOf<class UPL_StaticData> TargetClass) const;
	const class UPL_StaticData* GetDataByTagId(const struct FGameplayTag& TagId) const;
	void ReceiveGameEvent(class AActor* OwningActor, const struct FPL_StaticDataEventContext& Context) const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StaticActorData")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StaticActorData")
	}
	static class UPL_StaticActorData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StaticActorData>();
	}
};
DUMPER7_ASSERTS_UPL_StaticActorData;

// Class PL_Core.PL_StaticActorDataComponent
// 0x0010 (0x00D0 - 0x00C0)
class UPL_StaticActorDataComponent final : public UActorComponent
{
public:
	class UPL_StaticActorData*                    ActorData;                                         // 0x00C0(0x0008)(Edit, Net, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	uint8                                         Pad_C8[0x8];                                       // 0x00C8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static TSubclassOf<class AActor> GetActorClassFromActor(const class AActor* Actor);
	static const class UPL_StaticData* GetDataByClassFromActor(const class AActor* Actor, TSubclassOf<class UPL_StaticData> TargetClass);
	static const class UPL_StaticData* GetDataByTagIdFromActor(const class AActor* Actor, const struct FGameplayTag& TagId);
	static const class UPL_StaticData* GetDataFromActor(const class AActor* Actor, TSubclassOf<class UPL_StaticData> TargetClass, const struct FGameplayTag& TagId);
	static const class UPL_StaticActorData* GetStaticActorData(const class UObject* Object);
	static const class UPL_StaticActorDataComponent* GetStaticActorDataComponent(const class AActor* Actor);
	static void SendGameEventToStaticActorDataOnActor(class AActor* Actor, const struct FGameplayTag& EventId);

	TSubclassOf<class AActor> GetActorClass() const;
	const class UPL_StaticData* GetData(TSubclassOf<class UPL_StaticData> TargetClass, const struct FGameplayTag& TagId) const;
	const class UPL_StaticData* GetDataByClass(TSubclassOf<class UPL_StaticData> TargetClass) const;
	const class UPL_StaticData* GetDataByTagId(const struct FGameplayTag& TagId) const;
	void SendGameEventToStaticActorData(const struct FGameplayTag& EventId) const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StaticActorDataComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StaticActorDataComponent")
	}
	static class UPL_StaticActorDataComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StaticActorDataComponent>();
	}
};
DUMPER7_ASSERTS_UPL_StaticActorDataComponent;

// Class PL_Core.PL_StreamingObserverSubsystem
// 0x0050 (0x0080 - 0x0030)
class UPL_StreamingObserverSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x50];                                      // 0x0030(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_StreamingObserverSubsystem")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_StreamingObserverSubsystem")
	}
	static class UPL_StreamingObserverSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_StreamingObserverSubsystem>();
	}
};
DUMPER7_ASSERTS_UPL_StreamingObserverSubsystem;

// Class PL_Core.PL_PrecisionTiming
// 0x0000 (0x0028 - 0x0028)
class UPL_PrecisionTiming final : public UBlueprintFunctionLibrary
{
public:
	static double CyclesToSeconds(int64 Cycles);
	static struct FTimespan CyclesToTimespan(int64 Cycles);
	static int64 GetPrecisionCycles();
	static int64 GetPrecisionCyclesForSeconds(double Seconds);
	static int64 GetPrecisionCyclesPerSecond();
	static double GetPrecisionDeltaTime(int64 FirstCycles, int64 SecondCycles);
	static void RestoreAccumulatedPlaytime(const class UObject* WorldContextObject);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PrecisionTiming")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PrecisionTiming")
	}
	static class UPL_PrecisionTiming* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_PrecisionTiming>();
	}
};
DUMPER7_ASSERTS_UPL_PrecisionTiming;

// Class PL_Core.PL_PrecisionTimingSystem
// 0x0070 (0x00A0 - 0x0030)
class UPL_PrecisionTimingSystem final : public UGameInstanceSubsystem
{
public:
	int64                                         LastTickCycles;                                    // 0x0030(0x0008)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         LastTickCyclesDelta;                               // 0x0038(0x0008)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         TotalCycles;                                       // 0x0040(0x0008)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         TotalUnpausedCycles;                               // 0x0048(0x0008)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         TotalPausedCycles;                                 // 0x0050(0x0008)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPL_PrecisionTimingAccumulationMode           AccumulationMode;                                  // 0x0058(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_59[0x3];                                       // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaximumTickDurationSeconds;                        // 0x005C(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x40];                                      // 0x0060(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Reset();

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_PrecisionTimingSystem")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_PrecisionTimingSystem")
	}
	static class UPL_PrecisionTimingSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_PrecisionTimingSystem>();
	}
};
DUMPER7_ASSERTS_UPL_PrecisionTimingSystem;

// Class PL_Core.PL_BillboardedWidgetComponent
// 0x0000 (0x0710 - 0x0710)
class UPL_BillboardedWidgetComponent final : public UWidgetComponent
{
public:
	bool                                          bBillboardOnlyHorizontally;                        // 0x0708(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_709[0x7];                                      // 0x0709(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_BillboardedWidgetComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_BillboardedWidgetComponent")
	}
	static class UPL_BillboardedWidgetComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_BillboardedWidgetComponent>();
	}
};
DUMPER7_ASSERTS_UPL_BillboardedWidgetComponent;

// Class PL_Core.PL_WorldWidgetUtils
// 0x0000 (0x0028 - 0x0028)
class UPL_WorldWidgetUtils final : public UBlueprintFunctionLibrary
{
public:
	static void HideWorldWidgetLayers(const class APlayerController* PlayerController);

	void ShowWorldWidgetLayers(const class APlayerController* PlayerController);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WorldWidgetUtils")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WorldWidgetUtils")
	}
	static class UPL_WorldWidgetUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_WorldWidgetUtils>();
	}
};
DUMPER7_ASSERTS_UPL_WorldWidgetUtils;

// Class PL_Core.PL_IndicatorSystem
// 0x0020 (0x0050 - 0x0030)
class UPL_IndicatorSystem final : public ULocalPlayerSubsystem
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UPL_IndicatorWidgetController*>  IndicatorWidgetControllers;                        // 0x0040(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, UObjectWrapper, NativeAccessSpecifierProtected, TObjectPtr)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_IndicatorSystem")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_IndicatorSystem")
	}
	static class UPL_IndicatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_IndicatorSystem>();
	}
};
DUMPER7_ASSERTS_UPL_IndicatorSystem;

// Class PL_Core.PL_IndicatorWidgetController
// 0x0020 (0x0048 - 0x0028)
class UPL_IndicatorWidgetController final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UPL_IndicatorWidgetSetup*               IndicatorWidgetSetup;                              // 0x0030(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UWidget*                                Widget;                                            // 0x0038(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)
	class UObject*                                Source;                                            // 0x0040(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected, TObjectPtr)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_IndicatorWidgetController")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_IndicatorWidgetController")
	}
	static class UPL_IndicatorWidgetController* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_IndicatorWidgetController>();
	}
};
DUMPER7_ASSERTS_UPL_IndicatorWidgetController;

// Class PL_Core.PL_WidgetComponent
// 0x0020 (0x0730 - 0x0710)
class UPL_WidgetComponent final : public UWidgetComponent
{
public:
	uint8                                         Pad_708[0x8];                                      // 0x0708(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         LayerNameIndex;                                    // 0x0710(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bKeepOnScreen;                                     // 0x0714(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_715[0x1B];                                     // 0x0715(0x001B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WidgetComponent")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WidgetComponent")
	}
	static class UPL_WidgetComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_WidgetComponent>();
	}
};
DUMPER7_ASSERTS_UPL_WidgetComponent;

// Class PL_Core.PL_WidgetScreenLayerSelection
// 0x0000 (0x0028 - 0x0028)
class UPL_WidgetScreenLayerSelection final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PL_WidgetScreenLayerSelection")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PL_WidgetScreenLayerSelection")
	}
	static class UPL_WidgetScreenLayerSelection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPL_WidgetScreenLayerSelection>();
	}
};
DUMPER7_ASSERTS_UPL_WidgetScreenLayerSelection;

}